ai-optimize-master 0.0.0-stage → 0.3.2

package/lib/scan.mjs

@@ -0,0 +1,436 @@
+// Read-only inventory of AI-tool assets: skill roots, skill duplication, broken
+// local references, MCP configuration surfaces, and tool versions.
+// Invariant (O1): this module never writes. It only reads files and runs the
+// small set of version probes named in PROBES.
+import { readdir, stat } from 'node:fs/promises'
+import { join, basename } from 'node:path'
+import { homedir } from 'node:os'
+import { readTextIfExists, sha256Hex, expandHome } from './util.mjs'
+
+// Version probes are an allowlist, not a shell: we only ever spawn these names.
+// A binary that exists but fails to run must NOT be reported as usable (O3).
+const PROBES = [
+  { id: 'node', command: 'node', args: ['--version'] },
+  { id: 'git', command: 'git', args: ['--version'] },
+  { id: 'pwsh', command: process.platform === 'win32' ? 'pwsh' : 'pwsh', args: ['-NoProfile', '-Command', '$PSVersionTable.PSVersion.Major'] },
+  { id: 'claude', command: 'claude', args: ['--version'] },
+  { id: 'codex', command: 'codex', args: ['--version'] }
+]
+
+// Known skill roots. `optional: true` means "use it if present, stay quiet if
+// absent": a machine that has never installed Cursor should not get a finding for
+// it. Roots supplied explicitly by the caller are always reported when unreadable.
+export function defaultRoots(platform = process.platform) {
+  const home = homedir()
+  const dir = (...parts) => join(home, ...parts)
+  const roots = [
+    { id: 'dsh', label: 'DeepSeek Harness', dir: dir('.dsh', 'skills'), optional: true },
+    { id: 'agents', label: 'Agent Skills (cross-tool)', dir: dir('.agents', 'skills'), optional: true },
+    { id: 'agents-canonical', label: 'Agent Skills canonical source', dir: dir('.agents_skills'), optional: true },
+    { id: 'claude', label: 'Claude Code', dir: dir('.claude', 'skills'), optional: true },
+    { id: 'codex', label: 'Codex CLI', dir: dir('.codex', 'skills'), optional: true },
+    { id: 'openclaw', label: 'OpenClaw / ClawX', dir: dir('.openclaw', 'skills'), optional: true },
+    { id: 'cursor', label: 'Cursor', dir: dir('.cursor', 'skills'), optional: true },
+    { id: 'uking', label: 'U-King', dir: dir('.uking', 'skills'), optional: true },
+    // Other agents that follow the same <root>/<name>/SKILL.md convention.
+    // Paths are only used when they already exist; nothing is created.
+    { id: 'hermes', label: 'Hermes', dir: dir('.hermes', 'skills'), optional: true },
+    { id: 'opencode', label: 'OpenCode', dir: dir('.opencode', 'skills'), optional: true },
+    { id: 'pi', label: 'Pi', dir: dir('.pi', 'agent', 'skills'), optional: true },
+    { id: 'gemini', label: 'Gemini CLI', dir: dir('.gemini', 'skills'), optional: true },
+    { id: 'qwen', label: 'Qwen Code', dir: dir('.qwen', 'skills'), optional: true },
+    { id: 'trae', label: 'Trae', dir: dir('.trae', 'skills'), optional: true },
+    { id: 'windsurf', label: 'Windsurf', dir: dir('.windsurf', 'skills'), optional: true },
+    { id: 'qoder', label: 'Qoder', dir: dir('.qoder', 'skills'), optional: true },
+    { id: 'codebuddy', label: 'CodeBuddy', dir: dir('.codebuddy', 'skills'), optional: true },
+    { id: 'commandcode', label: 'CommandCode', dir: dir('.commandcode', 'skills'), optional: true },
+    { id: 'grok', label: 'Grok', dir: dir('.grok', 'skills'), optional: true },
+    { id: 'iflow', label: 'iFlow', dir: dir('.iflow', 'skills'), optional: true },
+    { id: 'lingma', label: 'Lingma', dir: dir('.lingma', 'skills'), optional: true },
+    { id: 'zcode', label: 'ZCode', dir: dir('.zcode', 'skills'), optional: true }
+  ]
+  // Extra roots (e.g. a shared Windows workstation tree) are explicit: an
+  // unreadable explicit root is reported, never silently ignored.
+  for (const extra of (process.env.DSH_OPTIMIZER_ROOTS ?? '').split(process.platform === 'win32' ? ';' : ':').filter(Boolean)) {
+    roots.push({ id: `extra:${basename(extra)}`, label: `Extra root ${extra}`, dir: expandHome(extra), optional: false })
+  }
+  return roots
+}
+
+export function defaultMcpConfigs(platform = process.platform) {
+  const home = homedir()
+  return [
+    { id: 'claude', label: 'Claude Code', file: join(home, '.claude.json') },
+    { id: 'codex', label: 'Codex CLI', file: join(home, '.codex', 'config.toml') },
+    { id: 'cursor', label: 'Cursor', file: join(home, '.cursor', 'mcp.json') }
+  ]
+}
+
+async function listSkillDirs(rootDir) {
+  let items
+  try {
+    items = await readdir(rootDir, { withFileTypes: true })
+  } catch (error) {
+    if (error?.code === 'ENOENT' || error?.code === 'EACCES' || error?.code === 'EPERM') return { skills: [], error: error.code }
+    throw error
+  }
+  const skills = []
+  for (const item of items) {
+    if (!item.isDirectory()) continue
+    const dir = join(rootDir, item.name)
+    const skillMd = join(dir, 'SKILL.md')
+    const text = await readTextIfExists(skillMd)
+    if (text === null) {
+      skills.push({ name: item.name, dir, hasSkillMd: false, skillMdHash: null, bytes: 0 })
+      continue
+    }
+    skills.push({ name: item.name, dir, hasSkillMd: true, skillMdHash: sha256Hex(text), bytes: Buffer.byteLength(text) })
+  }
+  return { skills }
+}
+
+// Relative local references such as `scripts/foo.mjs` or `references/bar.md`
+// that the skill body tells an agent to open.
+const REF_RE = /`((?:scripts|references|examples|assets|templates|docs)\/[^`\s)]+)`/g
+
+async function checkReferences(dir, text) {
+  const broken = []
+  const seen = new Set()
+  for (const match of text.matchAll(REF_RE)) {
+    const ref = match[1]
+    if (seen.has(ref)) continue
+    seen.add(ref)
+    if (ref.includes('*') || ref.includes('<') || ref.endsWith('/')) continue
+    try {
+      await stat(join(dir, ref))
+    } catch {
+      broken.push(ref)
+    }
+  }
+  return broken
+}
+
+// A skill that hardcodes Windows-only absolute paths while being read on POSIX
+// is a portability smell, never an automatic deletion (it may target a remote host).
+function platformHints(text, platform) {
+  const hints = []
+  if (/[A-Za-z]:\\\\|\\bC:\\\\Users\\\\|\\bD:\\\\/.test(text)) hints.push('windows-absolute-paths')
+  if (platform !== 'win32' && hints.length) hints.push('read-on-non-windows')
+  return hints
+}
+
+async function probeTools(probes = PROBES) {
+  const { spawn } = await import('node:child_process')
+  const results = []
+  for (const probe of probes) {
+    const result = await new Promise(resolve => {
+      let settled = false
+      const done = value => { if (!settled) { settled = true; resolve(value) } }
+      try {
+        const child = spawn(probe.command, probe.args, { stdio: ['ignore', 'pipe', 'pipe'] })
+        let out = ''
+        let err = ''
+        child.stdout.on('data', d => { out += d })
+        child.stderr.on('data', d => { err += d })
+        child.on('error', error => done({ id: probe.id, found: false, ran: false, reason: error.code === 'ENOENT' ? 'not-on-path' : String(error.code ?? error.message) }))
+        child.on('close', code => {
+          const text = (out || err).trim()
+          if (code === 0 && text) done({ id: probe.id, found: true, ran: true, version: text.split(/\r?\n/)[0].slice(0, 80) })
+          else done({ id: probe.id, found: true, ran: false, reason: code === 0 ? 'empty-output' : `exit-${code}` })
+        })
+        setTimeout(() => { try { child.kill('SIGKILL') } catch {} ; done({ id: probe.id, found: true, ran: false, reason: 'timeout' }) }, 5000)
+      } catch (error) {
+        done({ id: probe.id, found: false, ran: false, reason: String(error.message) })
+      }
+    })
+    results.push(result)
+  }
+  return results
+}
+
+function parseMcpSurface(id, text) {
+  if (text === null) return { id, present: false, servers: [], parsable: false }
+  if (id === 'codex') {
+    // TOML: count [mcp_servers.<name>] tables without a TOML dependency.
+    const servers = [...text.matchAll(/^\[mcp_servers\.([^\]]+)\]/gm)].map(m => m[1].replace(/^["']|["']$/g, ''))
+    return { id, present: true, servers: [...new Set(servers)], parsable: true, format: 'toml' }
+  }
+  try {
+    const json = JSON.parse(text)
+    const servers = Object.keys(json?.mcpServers ?? {})
+    return { id, present: true, servers, parsable: true, format: 'json' }
+  } catch {
+    return { id, present: true, servers: [], parsable: false, format: 'json' }
+  }
+}
+
+async function pathStateOf(dir) {
+  try {
+    const info = await stat(dir)
+    return { exists: true, directory: info.isDirectory() }
+  } catch {
+    return { exists: false, directory: false }
+  }
+}
+
+export async function scan(options = {}) {
+  const platform = options.platform ?? process.platform
+  const roots = options.roots ?? defaultRoots(platform)
+  const mcpConfigs = options.mcpConfigs ?? defaultMcpConfigs(platform)
+  const includeProbes = options.probes !== false
+
+  const inventories = []
+  const bySkillName = new Map()
+
+  for (const root of roots) {
+    if (root.optional) {
+      // Absent optional roots are "not installed", not an error and not a finding.
+      const state = await pathStateOf(root.dir)
+      if (!state.exists) continue
+    }
+    const { skills, error } = await listSkillDirs(root.dir)
+    const rootResult = {
+      id: root.id,
+      label: root.label,
+      dir: root.dir,
+      applicable: error === undefined,
+      notApplicableReason: error ? `unreadable: ${error}` : null,
+      skillCount: skills.length,
+      skills: []
+    }
+    for (const skill of skills) {
+      const record = {
+        name: skill.name,
+        dir: skill.dir,
+        hasSkillMd: skill.hasSkillMd,
+        skillMdHash: skill.skillMdHash,
+        bytes: skill.bytes,
+        brokenReferences: [],
+        platformHints: []
+      }
+      if (skill.hasSkillMd) {
+        const text = await readTextIfExists(join(skill.dir, 'SKILL.md'))
+        record.brokenReferences = await checkReferences(skill.dir, text)
+        record.platformHints = platformHints(text, platform)
+      }
+      rootResult.skills.push(record)
+      const list = bySkillName.get(skill.name) ?? []
+      list.push({ root: root.id, rootLabel: root.label, ...record })
+      bySkillName.set(skill.name, list)
+    }
+    // Context weight is what the agent pays every session. The estimate is
+    // explicitly labelled: bytes/4 is a heuristic, never a measured token count (O9).
+    rootResult.contextBytes = rootResult.skills.reduce((n, s) => n + (s.bytes ?? 0), 0)
+    rootResult.contextEstimate = {
+      value: Math.round(rootResult.contextBytes / 4),
+      estimator: 'bytes/4',
+      note: 'Estimate, not a measured tokenizer count.'
+    }
+    inventories.push(rootResult)
+  }
+
+  // Duplicate analysis distinguishes "same name" from "same content".
+  const duplicates = []
+  for (const [name, copies] of bySkillName) {
+    if (copies.length < 2) continue
+    const hashes = new Set(copies.map(c => c.skillMdHash).filter(Boolean))
+    const identical = hashes.size === 1 && copies.every(c => c.hasSkillMd)
+    duplicates.push({
+      name,
+      copies: copies.map(c => ({ root: c.root, rootLabel: c.rootLabel, dir: c.dir, skillMdHash: c.skillMdHash })),
+      classification: identical ? 'identical-copies' : 'diverged-copies',
+      note: identical
+        ? 'Same SKILL.md content in several tool roots. Duplicate definition only; it does not prove any copy is unused.'
+        : 'Same skill name but different SKILL.md content. Divergence must be reviewed before any cleanup.'
+    })
+  }
+
+  const mcp = []
+  for (const config of mcpConfigs) {
+    const text = await readTextIfExists(config.file)
+    mcp.push({ ...parseMcpSurface(config.id, text), label: config.label, file: config.file })
+  }
+
+  const tools = includeProbes ? await probeTools(options.probesList ?? PROBES) : []
+
+  const findings = buildFindings({ inventories, duplicates, mcp, tools, platform })
+
+  return {
+    schema: 'dsh-optimizer/scan/v0.2',
+    platform,
+    scannedAt: new Date().toISOString(),
+    readOnly: true,
+    roots: inventories,
+    duplicates,
+    mcp,
+    tools,
+    findings
+  }
+}
+
+function finding(id, title, severity, platform, extra = {}) {
+  return {
+    id,
+    title,
+    severity,
+    platform,
+    applicable: extra.applicable ?? true,
+    notApplicableReason: extra.notApplicableReason ?? null,
+    verified: extra.verified ?? { method: 'read-file', evidence: '' },
+    current: extra.current ?? null,
+    recommended: extra.recommended ?? null,
+    remediation: extra.remediation ?? null
+  }
+}
+
+function buildFindings({ inventories, duplicates, mcp, tools, platform }) {
+  const findings = []
+
+  // Unreadable roots must say so; "could not read" is never "clean" (O2).
+  for (const root of inventories) {
+    if (!root.applicable) {
+      findings.push(finding(
+        `skill-root.unreadable:${root.id}`,
+        `Skill root ${root.label} cannot be read`,
+        'info',
+        platform,
+        {
+          applicable: false,
+          notApplicableReason: root.notApplicableReason,
+          verified: { method: 'read-file', evidence: root.notApplicableReason },
+          current: root.dir
+        }
+      ))
+    }
+  }
+
+  const identical = duplicates.filter(d => d.classification === 'identical-copies')
+  if (identical.length) {
+    findings.push(finding(
+      'skills.identical-duplicates',
+      `${identical.length} skill name(s) exist as byte-identical copies in several tool roots`,
+      'info',
+      platform,
+      {
+        verified: { method: 'read-file', evidence: `${identical.length} groups share one SKILL.md hash` },
+        current: identical.map(d => ({ name: d.name, copies: d.copies.length })),
+        recommended: 'Review the owning tool for each copy before archiving. Identical content does not prove a copy is unused.',
+        remediation: null
+      }
+    ))
+  }
+
+  const diverged = duplicates.filter(d => d.classification === 'diverged-copies')
+  if (diverged.length) {
+    findings.push(finding(
+      'skills.diverged-duplicates',
+      `${diverged.length} skill name(s) exist with different content across roots`,
+      'medium',
+      platform,
+      {
+        verified: { method: 'read-file', evidence: `${diverged.length} groups have more than one SKILL.md hash` },
+        current: diverged.map(d => ({ name: d.name, hashes: new Set(d.copies.map(c => c.skillMdHash)).size })),
+        recommended: 'Decide a single source of truth per skill; do not archive until the divergent copy is reviewed.'
+      }
+    ))
+  }
+
+  const broken = []
+  for (const root of inventories) {
+    for (const skill of root.skills) {
+      if (skill.brokenReferences.length) broken.push({ root: root.id, name: skill.name, missing: skill.brokenReferences })
+    }
+  }
+  if (broken.length) {
+    findings.push(finding(
+      'skills.broken-references',
+      `${broken.length} skill(s) reference local files that do not exist`,
+      'medium',
+      platform,
+      {
+        verified: { method: 'read-file', evidence: `${broken.length} skill(s) with at least one missing relative reference` },
+        current: broken,
+        recommended: 'Repair the path or remove the dangling instruction. A skill that points at missing files misleads the agent.'
+      }
+    ))
+  }
+
+  const missingSkillMd = []
+  for (const root of inventories) {
+    for (const skill of root.skills) {
+      if (!skill.hasSkillMd) missingSkillMd.push({ root: root.id, name: skill.name, dir: skill.dir })
+    }
+  }
+  if (missingSkillMd.length) {
+    findings.push(finding(
+      'skills.no-skill-md',
+      `${missingSkillMd.length} directory/directories under a skill root have no SKILL.md`,
+      'info',
+      platform,
+      {
+        verified: { method: 'read-file', evidence: 'directory present, SKILL.md absent' },
+        current: missingSkillMd,
+        recommended: 'These are not discoverable as skills. Investigate before removing: another tool may use the directory.'
+      }
+    ))
+  }
+
+  const mcpTotal = mcp.reduce((n, m) => n + m.servers.length, 0)
+  findings.push(finding(
+    'mcp.surface',
+    `MCP declarations found: ${mcpTotal} server entry/entries across ${mcp.filter(m => m.present).length} config file(s)`,
+    'info',
+    platform,
+    {
+      verified: { method: 'read-file', evidence: 'parsed MCP config surfaces without executing any server' },
+      current: mcp.map(m => ({ id: m.id, present: m.present, parsable: m.parsable, servers: m.servers })),
+      recommended: 'MCP surfaces are read-only in this version. Starting a server or removing one is out of scope; a timeout never proves a server is dead.',
+      remediation: null
+    }
+  ))
+
+  for (const tool of tools) {
+    if (!tool.found) {
+      findings.push(finding(
+        `tool.missing:${tool.id}`,
+        `${tool.id} is not on PATH`,
+        'info',
+        platform,
+        {
+          applicable: false,
+          notApplicableReason: tool.reason,
+          verified: { method: 'ran', evidence: `spawn failed: ${tool.reason}` },
+          current: null
+        }
+      ))
+    } else if (!tool.ran) {
+      // O3: presence on PATH is not proof that the tool works.
+      findings.push(finding(
+        `tool.unusable:${tool.id}`,
+        `${tool.id} exists on PATH but did not run successfully`,
+        'medium',
+        platform,
+        {
+          verified: { method: 'ran', evidence: `spawned ${tool.id}; ${tool.reason}` },
+          current: { found: true, usable: false },
+          recommended: 'Investigate the failing executable. A file that exists is not an installed, working tool.'
+        }
+      ))
+    } else {
+      findings.push(finding(
+        `tool.version:${tool.id}`,
+        `${tool.id} reports a version`,
+        'info',
+        platform,
+        {
+          verified: { method: 'ran', evidence: tool.version },
+          current: { found: true, usable: true, version: tool.version }
+        }
+      ))
+    }
+  }
+
+  return findings
+}
+
+export { PROBES }

package/lib/util.mjs

@@ -0,0 +1,130 @@
+// Shared primitives: canonical JSON, sha256, byte-safe file io, filesystem snapshots.
+// Invariant: hashes over structured values MUST be key-order independent (see O10).
+import { createHash } from 'node:crypto'
+import { readFile, writeFile, readdir, stat, unlink, rename, mkdir, realpath } from 'node:fs/promises'
+import { join, relative, dirname, resolve, sep } from 'node:path'
+import { homedir } from 'node:os'
+
+// Deterministic JSON: object keys sorted recursively, arrays keep order.
+// Arrays are NOT sorted: step order and command arguments are semantic.
+export function canonicalStringify(value) {
+  if (value === null || typeof value !== 'object') return JSON.stringify(value)
+  if (Array.isArray(value)) return `[${value.map(canonicalStringify).join(',')}]`
+  const keys = Object.keys(value).sort()
+  return `{${keys.map(key => `${JSON.stringify(key)}:${canonicalStringify(value[key])}`).join(',')}}`
+}
+
+// Structured values go through canonicalStringify so the hash never depends on key insertion order.
+export function sha256Hex(value) {
+  const text = typeof value === 'string' ? value : canonicalStringify(value)
+  return createHash('sha256').update(text).digest('hex')
+}
+
+export function home() {
+  return process.env.DSH_OPTIMIZER_HOME || join(homedir(), '.dsh-optimizer')
+}
+
+export function expandHome(p) {
+  if (!p) return p
+  if (p === '~') return homedir()
+  if (p.startsWith('~/') || p.startsWith('~\\')) return join(homedir(), p.slice(2))
+  return p
+}
+
+export async function readBytesIfExists(file) {
+  try {
+    return await readFile(file)
+  } catch (error) {
+    if (error?.code === 'ENOENT') return null
+    throw error
+  }
+}
+
+export async function writeBytes(file, bytes) {
+  await mkdir(dirname(file), { recursive: true })
+  await writeFile(file, bytes)
+}
+
+export async function readTextIfExists(file) {
+  const bytes = await readBytesIfExists(file)
+  return bytes === null ? null : bytes.toString('utf8')
+}
+
+// Snapshot a tree as { relPath -> { size, mtimeMs, sha256 } }. Used by O1 (scan never writes).
+export async function snapshotTree(root) {
+  const entries = new Map()
+  async function walk(dir) {
+    let items
+    try {
+      items = await readdir(dir, { withFileTypes: true })
+    } catch (error) {
+      if (error?.code === 'ENOENT') return
+      throw error
+    }
+    for (const item of items) {
+      const absolute = join(dir, item.name)
+      if (item.isDirectory()) {
+        await walk(absolute)
+      } else if (item.isFile()) {
+        const info = await stat(absolute)
+        const bytes = await readFile(absolute)
+        entries.set(relative(root, absolute).replaceAll('\\', '/'), {
+          size: info.size,
+          mtimeMs: info.mtimeMs,
+          sha256: createHash('sha256').update(bytes).digest('hex')
+        })
+      }
+    }
+  }
+  await walk(root)
+  return entries
+}
+
+export function snapshotEqual(a, b) {
+  if (a.size !== b.size) return false
+  for (const [key, value] of a) {
+    const other = b.get(key)
+    if (!other) return false
+    if (value.size !== other.size || value.mtimeMs !== other.mtimeMs || value.sha256 !== other.sha256) return false
+  }
+  for (const key of b.keys()) {
+    if (!a.has(key)) return false
+  }
+  return true
+}
+
+export async function sha256Of(file) {
+  const bytes = await readBytesIfExists(file)
+  if (bytes === null) return null
+  return createHash('sha256').update(bytes).digest('hex')
+}
+
+export async function removeIfExists(file) {
+  try {
+    await unlink(file)
+  } catch (error) {
+    if (error?.code !== 'ENOENT') throw error
+  }
+}
+
+export async function movePath(from, to) {
+  await mkdir(dirname(to), { recursive: true })
+  await rename(from, to)
+}
+
+// Guard: a write target must stay inside one of the declared roots.
+export function isInside(root, target) {
+  const r = resolve(root)
+  const t = resolve(target)
+  return t === r || t.startsWith(r + sep)
+}
+
+export async function realpathOrNull(target) {
+  try { return await realpath(target) } catch { return null }
+}
+
+export function parseBool(value, fallback = false) {
+  if (value === undefined || value === null || value === '') return fallback
+  if (typeof value === 'boolean') return value
+  return ['1', 'true', 'yes', 'on'].includes(String(value).toLowerCase())
+}

package/mcp-server.mjs

@@ -0,0 +1,65 @@
+#!/usr/bin/env node
+// MCP surface — READ-ONLY by design.
+// A remote MCP caller may inspect and plan, but must not modify this machine:
+// apply and undo are deliberately absent. See SECURITY.md.
+import readline from 'node:readline'
+import { scan } from './lib/scan.mjs'
+import { buildPlan } from './lib/apply.mjs'
+
+const tools = [
+  {
+    name: 'optimizer_scan',
+    description: 'Read-only inventory of AI tool skill roots, duplicates, broken references, MCP declarations, and tool versions. Never writes.',
+    inputSchema: {
+      type: 'object',
+      properties: { includeProbes: { type: 'boolean' } },
+      additionalProperties: false
+    }
+  },
+  {
+    name: 'optimizer_plan',
+    description: 'Build a reviewable, hash-bound plan from a scan. Never modifies anything. Note: the MCP surface cannot apply a plan; apply/undo exist only on the local CLI and the DSH plugin.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        select: { type: 'array', items: { type: 'string' } },
+        root: { type: 'array', items: { type: 'string' } }
+      },
+      additionalProperties: false
+    }
+  }
+]
+
+async function call(name, args = {}) {
+  if (name === 'optimizer_scan') return scan({ probes: args.includeProbes ?? true })
+  if (name === 'optimizer_plan') {
+    const scanResult = await scan({ probes: false })
+    const selected = (args.select ?? []).map((skillName, index) => (args.root?.[index] ? { name: skillName, root: args.root[index] } : skillName))
+    return buildPlan(scanResult, { selections: selected })
+  }
+  throw Object.assign(new Error(`Unknown tool: ${name}`), { code: 'METHOD_NOT_FOUND' })
+}
+
+const send = value => process.stdout.write(`${JSON.stringify(value)}\n`)
+const lines = readline.createInterface({ input: process.stdin, crlfDelay: Infinity })
+
+for await (const line of lines) {
+  if (!line.trim()) continue
+  let request
+  try { request = JSON.parse(line) } catch { continue }
+  if (request.id === undefined) continue
+  try {
+    if (request.method === 'initialize') {
+      send({ jsonrpc: '2.0', id: request.id, result: { protocolVersion: request.params?.protocolVersion ?? '2025-06-18', capabilities: { tools: {} }, serverInfo: { name: 'ai-optimize-master', version: '0.3.2' } } })
+    } else if (request.method === 'tools/list') {
+      send({ jsonrpc: '2.0', id: request.id, result: { tools } })
+    } else if (request.method === 'tools/call') {
+      const value = await call(request.params?.name, request.params?.arguments ?? {})
+      send({ jsonrpc: '2.0', id: request.id, result: { content: [{ type: 'text', text: JSON.stringify(value, null, 2) }], isError: false } })
+    } else {
+      send({ jsonrpc: '2.0', id: request.id, error: { code: -32601, message: `Unknown method: ${request.method}` } })
+    }
+  } catch (error) {
+    send({ jsonrpc: '2.0', id: request.id, error: { code: -32000, message: error?.message ?? String(error) } })
+  }
+}