iterate-plugin 3.12.0 → 3.14.0

package/src/tools/config.ts

@@ -2,7 +2,7 @@ import { join } from 'node:path'
 import { existsSync, readFileSync } from 'node:fs'
 import { defineTool } from '@deepseek-ai/dsh-tools'
 import type { JsonValue } from '@deepseek-ai/dsh-util-values'
-import { defaultConfig, loadEffectiveConfig, validateConfig, resolveProjectRootForExec } from '../config-loader.ts'
+import { defaultConfig, loadEffectiveConfig, validateConfig, resolveProjectRootForExec, flattenCommands } from '../config-loader.ts'
 import {
   applyConfigUpdates,
   readRawConfig,
@@ -10,6 +10,7 @@ import {
   writeConfigFile,
 } from '../config-write.ts'
 import { withProjectLock } from '../file-lock.ts'
+import { buildValidationUpdates, detectValidationCommands } from '../validation-detect.ts'
 
 /**
  * Register the `iterate_config` tool.
@@ -21,16 +22,24 @@ export function registerConfigTool(ctx: { tools: { register: (def: ReturnType<ty
   ctx.tools.register(
     defineTool({
       name: 'iterate_config',
-      // `read` never writes; `write` persists a config update → only read
-      // joins a parallel dispatch group.
-      isConcurrencySafe: (args) => (args as { operation?: unknown }).operation !== 'write',
+      // `read` never writes; `write` persists a config update. `detect` is a
+      // read UNLESS it is asked to apply the detected commands.
+      isConcurrencySafe: (args) => {
+        const a = args as { operation?: unknown; apply?: unknown }
+        return a.operation !== 'write' && !(a.operation === 'detect' && a.apply === true)
+      },
       // Pending-call card: a config read vs a validated write.
       presentCall: (args) => {
-        const a = args as { operation?: unknown; section?: unknown }
-        const isWrite = a.operation === 'write'
+        const a = args as { operation?: unknown; section?: unknown; apply?: unknown }
+        const isWrite = a.operation === 'write' || (a.operation === 'detect' && a.apply === true)
+        const title = isWrite
+          ? 'Update iterate.config.yaml'
+          : a.operation === 'detect'
+            ? 'Detect validation commands'
+            : 'Read iterate.config.yaml'
         return {
           card: 'generic',
-          title: isWrite ? 'Update iterate.config.yaml' : 'Read iterate.config.yaml',
+          title,
           kind: isWrite ? 'edit' : 'read',
           ...(typeof a.section === 'string' && a.section ? { rawInput: { section: a.section } } : {}),
         }
@@ -39,13 +48,17 @@ export function registerConfigTool(ctx: { tools: { register: (def: ReturnType<ty
         'Read or update the iterate.config.yaml configuration from the project root. ' +
         'Returns the full parsed config, a specific section, or validation errors. ' +
         'Use this to discover available dimensions, validation commands, git settings, and personalization rules, ' +
-        'or to write back validated changes (goal, dimensions, max_rounds, review, atomic, validation, git, etc.).',
+        'or to write back validated changes (goal, dimensions, max_rounds, review, atomic, validation, git, etc.). ' +
+        'operation "detect" inspects the project manifest (package.json scripts / pytest / Cargo / Go / Make) and ' +
+        'proposes a ready-to-apply validation.commands set; pass apply:true to install it in one call.',
 
       parameters: {
         operation: {
           type: 'string',
-          description: 'Default "read". "write" validates and applies a partial config update (backed up first).',
-          enum: ['read', 'write'],
+          description:
+            'Default "read". "write" validates and applies a partial config update (backed up first). ' +
+            '"detect" proposes validation commands from the project manifest.',
+          enum: ['read', 'write', 'detect'],
         },
         path: {
           type: 'string',
@@ -60,6 +73,16 @@ export function registerConfigTool(ctx: { tools: { register: (def: ReturnType<ty
           type: 'boolean',
           description: 'If true, validate the config schema and return any missing fields.',
         },
+        apply: {
+          type: 'boolean',
+          description:
+            'For operation "detect": when true, install the detected commands under validation.commands.default ' +
+            '(refused if commands are already configured unless force:true).',
+        },
+        force: {
+          type: 'boolean',
+          description: 'For operation "detect" with apply:true: replace an existing default command set.',
+        },
         updates: {
           type: 'json',
           description:
@@ -83,6 +106,11 @@ export function registerConfigTool(ctx: { tools: { register: (def: ReturnType<ty
             availableSections: { type: 'array', items: { type: 'string' } },
             operation: { type: 'string' },
             ok: { type: 'boolean' },
+            applied: { type: 'boolean' },
+            ecosystem: { oneOf: [{ type: 'string' }, { type: 'null' }] },
+            commands: { type: 'array', items: { type: 'string' } },
+            sources: { type: 'json' },
+            updates: { type: 'json' },
             backupPath: { oneOf: [{ type: 'string' }, { type: 'null' }] },
             error: { type: 'string' },
           },
@@ -99,6 +127,81 @@ export function registerConfigTool(ctx: { tools: { register: (def: ReturnType<ty
         }
         const projectRoot = resolved.root
 
+        // ── Detect operation (validation-command auto-detection) ───────────
+        // Reads the project manifest and proposes a curated command set. With
+        // apply:true it installs the set under validation.commands.default in
+        // the same validated, backed-up, locked write path as operation:write.
+        if (args.operation === 'detect') {
+          const configPath = join(projectRoot, 'iterate.config.yaml')
+          const configExists = existsSync(configPath)
+          const detection = detectValidationCommands(projectRoot)
+          const updates = buildValidationUpdates(detection.commands)
+          const base = {
+            operation: 'detect',
+            found: configExists,
+            ecosystem: detection.ecosystem,
+            commands: detection.commands,
+            sources: detection.sources as unknown as JsonValue,
+            updates: updates as unknown as JsonValue,
+          }
+          if (detection.commands.length === 0) {
+            return {
+              ...base,
+              ok: false,
+              applied: false,
+              error:
+                'no validation commands detected — the project does not advertise a test/typecheck/lint/build ' +
+                'command; configure validation.commands manually',
+            }
+          }
+          if (args.apply !== true) {
+            return { ...base, ok: true, applied: false }
+          }
+          // Refuse to silently clobber a hand-tuned command set.
+          const current = loadEffectiveConfig(projectRoot).config
+          const existing = flattenCommands(current.validation?.commands)
+          if (existing.length > 0 && args.force !== true) {
+            return {
+              ...base,
+              ok: false,
+              applied: false,
+              error:
+                `validation.commands already has ${existing.length} command(s); ` +
+                'pass force:true to replace the "default" module',
+            }
+          }
+          return withProjectLock(projectRoot, 'config-write', () => {
+            let cfgBase: Record<string, unknown>
+            try {
+              cfgBase = configExists
+                ? readRawConfig(configPath)
+                : (defaultConfig() as unknown as Record<string, unknown>)
+            } catch (err) {
+              return { ...base, ok: false, applied: false, error: `failed to read config: ${String(err)}` }
+            }
+            const merged = applyConfigUpdates(cfgBase, updates)
+            const schemaErrors = validateConfig(merged)
+            if (schemaErrors.length > 0) {
+              return {
+                ...base,
+                ok: false,
+                applied: false,
+                errors: schemaErrors.map((e) => `missing/required field: ${e}`),
+              }
+            }
+            const result = writeConfigFile(projectRoot, merged)
+            if (!result.ok) return { ...base, ok: false, applied: false, error: result.error }
+            const { config } = loadEffectiveConfig(projectRoot)
+            return {
+              ...base,
+              ok: true,
+              applied: true,
+              backupPath: result.backupPath ?? null,
+              config: config as unknown as JsonValue,
+            }
+          })
+        }
+
         // ── Write operation ────────────────────────────────────────────────
         if (args.operation === 'write') {
           const updates = args.updates as Record<string, unknown> | undefined

package/src/tools/preflight.ts

@@ -25,6 +25,7 @@ import { readCheckpoint, computeStatus } from './checkpoint.ts'
 import { readDecisionEntries } from './decision-log.ts'
 import { readRegistry } from './fix.ts'
 import { resultHeadline } from './present.ts'
+import { detectValidationCommands } from '../validation-detect.ts'
 
 /** A single check's outcome. `fail` blocks a clean run; `warn` is advisory. */
 export type PreflightStatus = 'pass' | 'warn' | 'fail'
@@ -65,6 +66,12 @@ export interface PreflightInput {
   interrupted: boolean
   /** How many times the leftover checkpoint has already been resumed. */
   resumeCount: number
+  /** Commands auto-detected from the project manifest (only when none are configured). */
+  suggestedCommands?: string[]
+  /** Ecosystem that produced the suggestions (node/python/rust/go/make). */
+  ecosystem?: string | null
+  /** Manifest files the suggestions were derived from. */
+  detectedFrom?: string[]
 }
 
 /**
@@ -88,11 +95,23 @@ export interface PreflightInput {
  *                                progressed; `warn` + resume or clear.
  */
 export function buildPreflightReport(input: PreflightInput): PreflightReport {
+  const suggestions = Array.isArray(input.suggestedCommands) ? input.suggestedCommands.filter((c) => typeof c === 'string' && c.length > 0) : []
   const checks: PreflightCheck[] = [
     {
       id: 'validation',
       status: input.validationCommandCount > 0 ? 'pass' : 'fail',
-      detail: { commandCount: input.validationCommandCount },
+      detail: {
+        commandCount: input.validationCommandCount,
+        // Only meaningful when the blocking case is hit; the client turns these
+        // into a one-click "apply detected commands" action.
+        ...(input.validationCommandCount === 0 && suggestions.length > 0
+          ? {
+              suggestedCommands: suggestions,
+              ecosystem: input.ecosystem ?? null,
+              detectedFrom: Array.isArray(input.detectedFrom) ? input.detectedFrom : [],
+            }
+          : {}),
+      },
     },
     {
       id: 'git',
@@ -126,9 +145,17 @@ function describeCheck(id: string, detail: Record<string, unknown>): string {
   switch (id) {
     case 'validation': {
       const n = Number(detail.commandCount ?? 0)
-      return n > 0
-        ? `${n} validation command(s) configured`
-        : 'no validation.commands configured — the run cannot prove fixes (blocking)'
+      if (n > 0) return `${n} validation command(s) configured`
+      const suggested = Array.isArray(detail.suggestedCommands)
+        ? detail.suggestedCommands.map((c) => String(c))
+        : []
+      if (suggested.length > 0) {
+        return (
+          'no validation.commands configured — the run cannot prove fixes (blocking); ' +
+          `detected ${String(detail.ecosystem ?? 'project')} commands: ${suggested.join(', ')}`
+        )
+      }
+      return 'no validation.commands configured — the run cannot prove fixes (blocking)'
     }
     case 'git':
       return detail.isRepo === true
@@ -229,6 +256,24 @@ export function registerPreflightTool(ctx: { tools: { register: (def: ReturnType
           validationCommandCount = 0
         }
 
+        // 1b. When nothing is configured, inspect the project manifest so the
+        //     blocking check ships with an actionable, ready-to-apply set.
+        let suggestedCommands: string[] = []
+        let detectedEcosystem: string | null = null
+        let detectedFrom: string[] = []
+        if (validationCommandCount === 0) {
+          try {
+            const detection = detectValidationCommands(projectRoot)
+            suggestedCommands = detection.commands
+            detectedEcosystem = detection.ecosystem
+            detectedFrom = detection.sources.map((s) => s.file)
+          } catch {
+            suggestedCommands = []
+            detectedEcosystem = null
+            detectedFrom = []
+          }
+        }
+
         // 2/3. git repo + dirty tree (best-effort; any failure degrades to unknown).
         let isGitRepo = false
         let changedFiles: number | null = null
@@ -281,6 +326,9 @@ export function registerPreflightTool(ctx: { tools: { register: (def: ReturnType
           gateOverallStatus,
           interrupted,
           resumeCount,
+          suggestedCommands,
+          ecosystem: detectedEcosystem,
+          detectedFrom,
         })
         return { ...report, checks: report.checks as unknown as JsonValue }
       },

package/src/validation-detect.ts

@@ -0,0 +1,207 @@
+/**
+ * src/validation-detect.ts — detect a project's validation commands.
+ *
+ * Why it exists: the iterate loop is fail-closed on `validation.commands` — an
+ * empty set means it cannot tell a fix from a regression, so `iterate_preflight`
+ * blocks the run. Until now the only remedy was to hand-write the YAML, which is
+ * error-prone (wrong nesting, wrong module key, commands the project does not
+ * actually expose). This module inspects the project's own manifest files and
+ * proposes a small, curated command set that the config tool can apply in one
+ * call.
+ *
+ * Detection is advisory and read-only: it only proposes commands the project's
+ * manifest actually advertises (package.json scripts, pytest/ruff/mypy config,
+ * Cargo, Go, Make targets). It never invents a command and never executes one.
+ */
+
+import { existsSync, readFileSync } from 'node:fs'
+import { join } from 'node:path'
+
+/** Ecosystems this module knows how to read a manifest for. */
+export type Ecosystem = 'node' | 'python' | 'rust' | 'go' | 'make'
+
+/** One manifest fact that produced a command. */
+export interface DetectionSource {
+  /** Manifest file, relative to the project root. */
+  file: string
+  /** Short machine-stable reason, e.g. `scripts.test`. */
+  reason: string
+}
+
+/** The result of inspecting a project root. */
+export interface ValidationDetection {
+  /** The ecosystem that produced the first command, or null when none matched. */
+  ecosystem: Ecosystem | null
+  /** Ordered, de-duplicated commands for `validation.commands.default`. */
+  commands: string[]
+  /** One entry per command, same order/length as `commands`. */
+  sources: DetectionSource[]
+}
+
+/** Hard cap so a project with many scripts cannot flood the config. */
+const MAX_COMMANDS = 6
+
+function readText(path: string): string | null {
+  try {
+    return readFileSync(path, 'utf-8')
+  } catch {
+    return null
+  }
+}
+
+function readJsonObject(path: string): Record<string, unknown> | null {
+  const text = readText(path)
+  if (text === null) return null
+  try {
+    const parsed: unknown = JSON.parse(text)
+    // A JSON array / scalar is not a manifest object — treat it as absent.
+    return parsed !== null && typeof parsed === 'object' && !Array.isArray(parsed)
+      ? (parsed as Record<string, unknown>)
+      : null
+  } catch {
+    return null
+  }
+}
+
+function existsFile(root: string, name: string): boolean {
+  try {
+    return existsSync(join(root, name))
+  } catch {
+    return false
+  }
+}
+
+function asRecord(value: unknown): Record<string, unknown> {
+  return value !== null && typeof value === 'object' && !Array.isArray(value)
+    ? (value as Record<string, unknown>)
+    : {}
+}
+
+type AddCommand = (command: string, file: string, reason: string) => void
+
+/** Node: only scripts the manifest explicitly defines, in a curated order. */
+function detectNode(root: string, add: AddCommand): boolean {
+  const pkg = readJsonObject(join(root, 'package.json'))
+  if (!pkg) return false
+  const scripts = asRecord(pkg.scripts)
+  const has = (name: string): boolean =>
+    typeof scripts[name] === 'string' && (scripts[name] as string).trim().length > 0
+  // test/typecheck/lint/build are the four signals that actually prove a change
+  // is sound. Arbitrary user scripts are intentionally NOT auto-run.
+  if (has('test')) add('npm test', 'package.json', 'scripts.test')
+  if (has('typecheck')) add('npm run typecheck', 'package.json', 'scripts.typecheck')
+  if (has('lint')) add('npm run lint', 'package.json', 'scripts.lint')
+  if (has('build')) add('npm run build', 'package.json', 'scripts.build')
+  return true
+}
+
+/** Python: pytest plus configured ruff / mypy. A bare pyproject is not pytest. */
+function detectPython(root: string, add: AddCommand): boolean {
+  const pyproject = readText(join(root, 'pyproject.toml'))
+  const setupCfg = readText(join(root, 'setup.cfg'))
+  const pytestIni = existsFile(root, 'pytest.ini')
+  const toxIni = existsFile(root, 'tox.ini')
+  const testsDir = existsFile(root, 'tests')
+  const pyprojectPytest = pyproject !== null && /\[tool\.pytest/.test(pyproject)
+  const setupCfgPytest = setupCfg !== null && /\[tool:pytest\]/.test(setupCfg)
+  const matched = pyproject !== null || setupCfg !== null || pytestIni || toxIni || testsDir
+  if (!matched) return false
+
+  if (pytestIni) add('pytest -q', 'pytest.ini', 'pytest')
+  else if (toxIni) add('pytest -q', 'tox.ini', 'pytest')
+  else if (pyprojectPytest) add('pytest -q', 'pyproject.toml', 'tool.pytest')
+  else if (setupCfgPytest) add('pytest -q', 'setup.cfg', 'tool:pytest')
+  else if (testsDir) add('pytest -q', 'tests', 'tests-dir')
+
+  if (pyproject !== null && /\[tool\.ruff/.test(pyproject)) add('ruff check .', 'pyproject.toml', 'tool.ruff')
+  if (pyproject !== null && /\[tool\.mypy\]/.test(pyproject)) add('mypy .', 'pyproject.toml', 'tool.mypy')
+  return true
+}
+
+/** Rust: cargo test, plus clippy/rustfmt when the project configures them. */
+function detectRust(root: string, add: AddCommand): boolean {
+  if (!existsFile(root, 'Cargo.toml')) return false
+  add('cargo test', 'Cargo.toml', 'cargo.test')
+  if (existsFile(root, 'clippy.toml') || existsFile(root, '.clippy.toml')) {
+    add('cargo clippy --all-targets -- -D warnings', 'clippy.toml', 'cargo.clippy')
+  }
+  if (existsFile(root, 'rustfmt.toml') || existsFile(root, '.rustfmt.toml')) {
+    add('cargo fmt --check', 'rustfmt.toml', 'cargo.fmt')
+  }
+  return true
+}
+
+/** Go: test + vet are the two checks a go module always supports. */
+function detectGo(root: string, add: AddCommand): boolean {
+  if (!existsFile(root, 'go.mod')) return false
+  add('go test ./...', 'go.mod', 'go.test')
+  add('go vet ./...', 'go.mod', 'go.vet')
+  return true
+}
+
+/** Make: the generic fallback, only when no ecosystem-specific command exists. */
+function detectMake(root: string, add: AddCommand): boolean {
+  const makefile = ['Makefile', 'makefile', 'GNUmakefile'].find((name) => existsFile(root, name))
+  if (!makefile) return false
+  const text = readText(join(root, makefile)) ?? ''
+  const targets = new Set<string>()
+  for (const line of text.split(/\r?\n/)) {
+    // `target:`, but NOT a `VAR := value` / `VAR = value` assignment. The
+    // lookahead has to skip the optional space before `=` (`test := nope`).
+    const match = /^([A-Za-z0-9_.-]+)\s*:(?!=|\s*=)/.exec(line)
+    if (match) targets.add(match[1] as string)
+  }
+  if (targets.has('test')) add('make test', makefile, 'target.test')
+  if (targets.has('check')) add('make check', makefile, 'target.check')
+  return true
+}
+
+/**
+ * Inspect `projectRoot` and return a curated, ordered validation-command set.
+ *
+ * Never throws: unreadable or malformed manifests simply contribute nothing.
+ * The returned `commands` and `sources` always have the same length.
+ */
+export function detectValidationCommands(projectRoot: string): ValidationDetection {
+  const commands: string[] = []
+  const sources: DetectionSource[] = []
+  const seen = new Set<string>()
+  const add: AddCommand = (command, file, reason) => {
+    if (commands.length >= MAX_COMMANDS) return
+    if (seen.has(command)) return
+    seen.add(command)
+    commands.push(command)
+    sources.push({ file, reason })
+  }
+
+  let ecosystem: Ecosystem | null = null
+  const run = (name: Ecosystem, detect: (add: AddCommand) => boolean): void => {
+    const before = commands.length
+    let matched = false
+    try {
+      matched = detect(add)
+    } catch {
+      matched = false
+    }
+    if (matched && commands.length > before && ecosystem === null) ecosystem = name
+  }
+
+  run('node', (a) => detectNode(projectRoot, a))
+  run('python', (a) => detectPython(projectRoot, a))
+  run('rust', (a) => detectRust(projectRoot, a))
+  run('go', (a) => detectGo(projectRoot, a))
+  // Make is the generic wrapper: only consult it when nothing else produced a
+  // command, so a Makefile that just calls `npm test` does not double-report.
+  if (commands.length === 0) run('make', (a) => detectMake(projectRoot, a))
+
+  return { ecosystem, commands, sources }
+}
+
+/**
+ * Build the partial config update that installs a detected command set under
+ * the `default` module. The config tool deep-merges this into an existing
+ * `validation.commands` map, so other modules are preserved.
+ */
+export function buildValidationUpdates(commands: string[]): Record<string, unknown> {
+  return { validation: { commands: { default: [...commands] } } }
+}