feat(verify): Python verification + modular architecture + verified headers (#496)

* feat(verify): add Python verification support (15/17 passing)

- Add PYTHON_MODULES mapping for string and math module functions
- Add convertJsLineToPython with JS→Python syntax conversions:
  - true/false/null/undefined → True/False/None
  - Infinity/NaN → float('inf')/float('nan')
  - .length → len()
- Add jsToPython to generate runnable Python code with imports
- Add Python verification logic in verifyFunction
- Normalize Python float output (.0 stripping)
- Bump CACHE_VERSION to 5

Results: 15/17 Python functions pass verification against Python 3.12
Remaining failures:
- capwords: JS preserves double spaces, Python collapses them
- printable: .length on function result not converted

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

* feat(verify): refactor to modular architecture with verified header support

Architecture changes:
- Split verify.ts (1000+ lines) into modular structure:
  - scripts/verify/types.ts - Shared interfaces
  - scripts/verify/cache.ts - Caching utilities
  - scripts/verify/docker.ts - Docker utilities
  - scripts/verify/runner.ts - JS execution
  - scripts/verify/parser.ts - Function file parsing
  - scripts/verify/languages/index.ts - Language registry
  - scripts/verify/languages/php.ts - PHP handler
  - scripts/verify/languages/python.ts - Python handler
- Main verify.ts is now ~250 lines CLI entry point

New features:
- Add `verified: X.Y` header support in function files
  - Functions with header are verified in CI mode (default)
  - Functions without header are skipped unless --all is used
- Add --summary flag to show verification status counts
- Add --all flag to include unverified functions

CI integration:
- Default mode only runs functions with verified: header
- Exit code 1 only for verified function failures
- Unverified functions shown as "skipped" count

Demo verified headers added:
- src/php/strings/trim.js: verified: 8.3
- src/python/math/factorial.js: verified: 3.12

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

---------

Co-authored-by: Claude Opus 4.5 <noreply@anthropic.com>

Author: kvz

scripts/verify.ts

@@ -0,0 +1,60 @@
+/**
+ * Caching utilities for verification results
+ */
+
+import { createHash } from 'node:crypto'
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs'
+import { join } from 'node:path'
+import type { CacheEntry } from './types.ts'
+
+export const CACHE_VERSION = 6
+
+/**
+ * Calculate hash of file, its dependencies, and verify script
+ * Including verify script ensures cache invalidation when translation logic changes
+ */
+export function calculateHash(filePath: string, deps: string[], srcDir: string, verifyScriptPath: string): string {
+  const hash = createHash('sha256')
+
+  // Include verify script content so translation changes invalidate cache
+  hash.update(readFileSync(verifyScriptPath))
+  hash.update(readFileSync(filePath))
+
+  for (const dep of deps) {
+    const depPath = join(srcDir, dep)
+    if (existsSync(depPath)) {
+      hash.update(readFileSync(depPath))
+    }
+  }
+
+  return hash.digest('hex').slice(0, 16)
+}
+
+/**
+ * Load cached verification results for a function
+ */
+export function loadCache(funcPath: string, cacheDir: string): CacheEntry | null {
+  const cacheFile = join(cacheDir, funcPath.replace(/\//g, '_') + '.json')
+  if (!existsSync(cacheFile)) {
+    return null
+  }
+
+  try {
+    const entry = JSON.parse(readFileSync(cacheFile, 'utf8')) as CacheEntry
+    if (entry.version !== CACHE_VERSION) {
+      return null
+    }
+    return entry
+  } catch {
+    return null
+  }
+}
+
+/**
+ * Save verification results to cache
+ */
+export function saveCache(funcPath: string, entry: CacheEntry, cacheDir: string): void {
+  mkdirSync(cacheDir, { recursive: true })
+  const cacheFile = join(cacheDir, funcPath.replace(/\//g, '_') + '.json')
+  writeFileSync(cacheFile, JSON.stringify(entry, null, 2))
+}

scripts/verify/cache.ts

@@ -0,0 +1,80 @@
+/**
+ * Docker utilities for running code in language runtimes
+ */
+
+import { execSync, spawnSync } from 'node:child_process'
+
+/**
+ * Check if Docker image exists, pull if not
+ */
+export function ensureDockerImage(image: string): boolean {
+  try {
+    execSync(`docker image inspect ${image}`, { stdio: 'pipe' })
+    return true
+  } catch {
+    console.log(`  Pulling ${image}...`)
+    try {
+      execSync(`docker pull ${image}`, { stdio: 'pipe' })
+      return true
+    } catch {
+      return false
+    }
+  }
+}
+
+/**
+ * Check if Docker is available
+ */
+export function checkDockerAvailable(): boolean {
+  try {
+    execSync('docker --version', { stdio: 'pipe' })
+    return true
+  } catch {
+    return false
+  }
+}
+
+export interface DockerRunResult {
+  success: boolean
+  output: string
+  error?: string
+}
+
+/**
+ * Run code in a Docker container
+ */
+export function runInDocker(
+  image: string,
+  cmd: string[],
+  options: { mountRepo?: boolean; repoPath?: string; timeout?: number } = {},
+): DockerRunResult {
+  const { mountRepo = false, repoPath, timeout = 10000 } = options
+
+  try {
+    const dockerArgs = ['run', '--rm', '-i']
+    if (mountRepo && repoPath) {
+      dockerArgs.push('-v', `${repoPath}:/work`, '-w', '/work')
+    }
+
+    const result = spawnSync('docker', [...dockerArgs, image, ...cmd], {
+      encoding: 'utf8',
+      timeout,
+    })
+
+    if (result.error) {
+      return { success: false, output: '', error: result.error.message }
+    }
+
+    if (result.status !== 0 || (result.stderr && result.stderr.trim())) {
+      return {
+        success: false,
+        output: result.stdout || '',
+        error: result.stderr?.trim() || 'Unknown error',
+      }
+    }
+
+    return { success: true, output: result.stdout }
+  } catch (e) {
+    return { success: false, output: '', error: String(e) }
+  }
+}

scripts/verify/docker.ts

@@ -0,0 +1,34 @@
+/**
+ * Language handler registry
+ */
+
+import type { LanguageHandler } from '../types.ts'
+import { phpHandler } from './php.ts'
+import { pythonHandler } from './python.ts'
+
+const handlers: Record<string, LanguageHandler> = {
+  php: phpHandler,
+  python: pythonHandler,
+}
+
+/**
+ * Get the language handler for a given language
+ * Returns undefined if the language is not supported yet
+ */
+export function getLanguageHandler(language: string): LanguageHandler | undefined {
+  return handlers[language]
+}
+
+/**
+ * Check if a language has verification support
+ */
+export function isLanguageSupported(language: string): boolean {
+  return language in handlers
+}
+
+/**
+ * Get all supported languages
+ */
+export function getSupportedLanguages(): string[] {
+  return Object.keys(handlers)
+}