@glrs-dev/cli 2.4.0 → 2.4.1

package/dist/node_modules/@glrs-dev/autopilot/dist/chunk-ZNJWARTM.js

@@ -0,0 +1,449 @@
+import {
+  childLogger
+} from "./chunk-Q4ULU6ER.js";
+import {
+  detectSpecPhases,
+  hasSpec,
+  parseSpecItems
+} from "./chunk-7OSEI5TF.js";
+
+// src/plan-enrichment.ts
+import * as fs from "fs";
+import * as path from "path";
+import { parse as yamlParse, stringify as yamlStringify } from "yaml";
+var ENRICHMENT_RATIO_THRESHOLD = 1;
+function computeEnrichmentRatio(planFiles) {
+  let total = 0;
+  let enriched = 0;
+  for (const f of planFiles) {
+    let content;
+    try {
+      content = fs.readFileSync(f, "utf-8");
+    } catch {
+      continue;
+    }
+    const checkboxItems = (content.match(/^- \[[ xX]\]/gm) ?? []).length;
+    const headingItems = (content.match(/^###\s+\d+\.\d+\s/gm) ?? []).length;
+    total += headingItems > 0 ? headingItems : checkboxItems;
+    const hasMirror = (content.match(/^\s*-?\s*mirror:/gm) ?? []).length;
+    const hasContext = (content.match(/^\s*-?\s*context/gm) ?? []).length;
+    const hasConventions = (content.match(/^\s*-?\s*conventions:/gm) ?? []).length;
+    enriched += Math.min(hasMirror, hasContext, hasConventions);
+  }
+  return total > 0 ? enriched / total : 0;
+}
+function computeSpecEnrichmentRatio(planDir) {
+  if (!hasSpec(planDir)) return 0;
+  const phaseFiles = detectSpecPhases(planDir);
+  let total = 0;
+  let enriched = 0;
+  for (const phaseFile of phaseFiles) {
+    const phasePath = path.join(planDir, "spec", phaseFile);
+    const items = parseSpecItems(phasePath);
+    total += items.length;
+    for (const item of items) {
+      const it = item;
+      if (it.mirror && it.context && it.conventions) {
+        enriched++;
+      }
+    }
+  }
+  return total > 0 ? enriched / total : 0;
+}
+function buildSpecGenerationPrompt(planDir, phaseFile, content) {
+  const isMain = phaseFile === "main.md";
+  const specFileName = isMain ? "main.yaml" : phaseFile.replace(/\.md$/, ".yaml");
+  const specPath = `spec/${specFileName}`;
+  const schemaExample = isMain ? `\`\`\`yaml
+# spec/main.yaml
+title: "Plan title from H1"
+goal: "Goal text"
+constraints: "Constraints text"
+phases:
+  - file: wave_0.yaml
+    completed: false
+\`\`\`` : `\`\`\`yaml
+# spec/${specFileName}
+items:
+  - id: "0.1"
+    intent: "What this item does"
+    checked: false
+    files:
+      - path: src/foo.ts
+        isNew: false
+        change: "What changes"
+    tests:
+      - "test/foo.test.ts"
+    verify: "bun test test/foo.test.ts"
+    mirror: "src/similar-file.ts"
+    context: |
+      // relevant code from the file being modified
+    conventions: "ESM imports, named exports, bun:test"
+\`\`\``;
+  const mainInstructions = `You are generating a YAML spec file from a markdown plan.
+
+Read the markdown plan content below and write \`${specPath}\` (relative to the plan directory: ${planDir}) using the write/edit tool.
+
+The output file should follow this schema:
+
+${schemaExample}
+
+Extract from the markdown:
+- \`title\`: the H1 heading text
+- \`goal\`: the Goal section text
+- \`constraints\`: the Constraints section text (if present)
+- \`phases\`: one entry per phase file referenced (e.g., wave_0.md \u2192 wave_0.yaml), all with \`completed: false\`
+
+Here is the plan file to convert:
+
+### ${phaseFile}
+\`\`\`markdown
+${content}
+\`\`\`
+
+Write the file \`${planDir}/${specPath}\` using the write/edit tool, then respond with "SPEC_COMPLETE" when done.`;
+  const phaseInstructions = `You are generating a YAML spec file from a markdown plan phase, enriched with codebase context.
+
+Read the markdown plan content below and write \`${specPath}\` (relative to the plan directory: ${planDir}) using the write/edit tool.
+
+The output file should follow this schema:
+
+${schemaExample}
+
+For each acceptance-criteria item in the plan:
+1. Extract \`id\`, \`intent\`, \`files\`, \`tests\`, \`verify\` from the markdown.
+2. Set \`checked: false\` for all items.
+3. Add enrichment fields by reading the actual codebase:
+   - **mirror**: Find the most similar existing file in the codebase and set \`mirror: <path>\`. This is the pattern-match target the executor will follow.
+   - **context**: For each file being MODIFIED (not NEW), read the relevant function/section and add 10-20 lines of the current code. For NEW files, add the key function signatures the file should export.
+   - **conventions**: List project-specific patterns: import style (named vs default), export pattern, test framework (vitest/jest/bun:test), naming conventions, error handling pattern.
+
+Rules:
+- Read actual files from the codebase to get accurate code pointers. Do not hallucinate file contents.
+- Be concise \u2014 10-20 lines of context per file, not the whole file.
+- Only add enrichment fields you can verify from the codebase.
+
+Here is the plan file to convert:
+
+### ${phaseFile}
+\`\`\`markdown
+${content}
+\`\`\`
+
+Write the file \`${planDir}/${specPath}\` using the write/edit tool, then respond with "SPEC_COMPLETE" when done.`;
+  return isMain ? mainInstructions : phaseInstructions;
+}
+async function enrichPlanForFastModel(cwd, planPath, logger, emitter, adapter) {
+  const log = logger ? childLogger(logger.root, "autopilot.enrichment") : void 0;
+  const resolvedPath = path.resolve(cwd, planPath);
+  const isDir = fs.existsSync(resolvedPath) && fs.statSync(resolvedPath).isDirectory();
+  let planFiles;
+  if (isDir) {
+    const entries = fs.readdirSync(resolvedPath);
+    planFiles = entries.filter((f) => f.endsWith(".md") && f !== "scope.md" && f !== "scope-seed.md").sort((a, b) => {
+      if (a === "main.md") return -1;
+      if (b === "main.md") return 1;
+      const numA = parseInt(a.replace(/[^0-9]/g, ""), 10) || 0;
+      const numB = parseInt(b.replace(/[^0-9]/g, ""), 10) || 0;
+      return numA - numB;
+    }).map((f) => path.join(resolvedPath, f));
+  } else {
+    planFiles = [resolvedPath];
+  }
+  emitter?.emitEvent({
+    type: "enrich:start",
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    planPath: resolvedPath,
+    fileCount: planFiles.length
+  });
+  const isYamlSpec = isDir && hasSpec(resolvedPath);
+  const wholePlanRatio = isYamlSpec ? computeSpecEnrichmentRatio(resolvedPath) : computeEnrichmentRatio(planFiles);
+  if (wholePlanRatio >= ENRICHMENT_RATIO_THRESHOLD) {
+    log?.info({ ratio: wholePlanRatio }, "Plan already enriched \u2014 skipping");
+    emitter?.emitEvent({
+      type: "enrich:done",
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      filesProcessed: 0
+    });
+    return;
+  }
+  if (isDir) {
+    fs.mkdirSync(path.join(resolvedPath, "spec"), { recursive: true });
+  }
+  const existingMainYaml = path.join(resolvedPath, "spec", "main.yaml");
+  let savedCompletionStates = null;
+  try {
+    if (fs.existsSync(existingMainYaml)) {
+      const content = fs.readFileSync(existingMainYaml, "utf-8");
+      const raw = yamlParse(content);
+      if (raw && Array.isArray(raw.phases)) {
+        savedCompletionStates = /* @__PURE__ */ new Map();
+        for (const phase of raw.phases) {
+          if (phase.file && phase.completed === true) {
+            savedCompletionStates.set(phase.file, true);
+          }
+        }
+      }
+    }
+  } catch {
+  }
+  log?.info({ planPath: resolvedPath, fileCount: planFiles.length }, "Starting enrichment");
+  log?.info("Starting OpenCode server for enrichment...");
+  if (!adapter) {
+    throw new Error("enrichPlanForFastModel: adapter is required");
+  }
+  const handle = await adapter.start({ cwd });
+  log?.info({ agentId: handle.id }, "Agent ready for enrichment");
+  let enrichmentCumulativeCost = 0;
+  try {
+    for (const f of planFiles) {
+      const rel = path.relative(cwd, f);
+      const phaseFile = path.basename(f);
+      const specFileName = phaseFile === "main.md" ? "main.yaml" : phaseFile.replace(/\.md$/, ".yaml");
+      const specPath = isDir ? path.join(resolvedPath, "spec", specFileName) : null;
+      if (specPath && fs.existsSync(specPath)) {
+        if (phaseFile === "main.md") {
+          log?.info({ file: rel }, "Spec already exists \u2014 skipping");
+          emitter?.emitEvent({
+            type: "enrich:file:skip",
+            timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+            file: rel,
+            reason: "spec already exists"
+          });
+          continue;
+        }
+        const phaseItems = parseSpecItems(specPath);
+        if (phaseItems.some((it) => it.checked)) {
+          log?.info({ file: rel }, "Phase has checked items \u2014 skipping re-enrichment");
+          emitter?.emitEvent({
+            type: "enrich:file:skip",
+            timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+            file: rel,
+            reason: "phase has checked items (in-progress)"
+          });
+          continue;
+        }
+        const phaseTotal = phaseItems.length;
+        const phaseEnriched = phaseItems.filter(
+          (it) => {
+            const item = it;
+            return item.mirror && item.context && item.conventions;
+          }
+        ).length;
+        const phaseRatio = phaseTotal > 0 ? phaseEnriched / phaseTotal : 0;
+        if (phaseRatio >= ENRICHMENT_RATIO_THRESHOLD) {
+          log?.info({ file: rel, ratio: phaseRatio }, "Phase spec already enriched \u2014 skipping");
+          emitter?.emitEvent({
+            type: "enrich:file:skip",
+            timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+            file: rel,
+            reason: `already enriched (${Math.round(phaseRatio * 100)}%)`
+          });
+          continue;
+        }
+      }
+      let content;
+      try {
+        content = fs.readFileSync(f, "utf-8");
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        log?.warn({ file: rel, err: msg }, "File read failed \u2014 skipping");
+        emitter?.emitEvent({
+          type: "enrich:file:error",
+          timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+          file: rel,
+          error: `read failed: ${msg}`
+        });
+        continue;
+      }
+      if (phaseFile !== "main.md") {
+        const checkboxItems = (content.match(/^- \[[ xX]\]/gm) ?? []).length;
+        const headingItems = (content.match(/^###\s+\d+\.\d+\s/gm) ?? []).length;
+        const itemCount = Math.max(checkboxItems, headingItems);
+        if (itemCount === 0) {
+          log?.info({ file: rel }, "No enrichable items \u2014 skipping");
+          emitter?.emitEvent({
+            type: "enrich:file:skip",
+            timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+            file: rel,
+            reason: "no enrichable items"
+          });
+          continue;
+        }
+      }
+      emitter?.emitEvent({
+        type: "enrich:file:start",
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        file: rel
+      });
+      let sessionId;
+      try {
+        sessionId = await adapter.createSession(handle, {
+          agentName: "prime"
+        });
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        log?.warn({ file: rel, err: msg }, "createSession failed \u2014 skipping");
+        emitter?.emitEvent({
+          type: "enrich:file:error",
+          timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+          file: rel,
+          error: `createSession failed: ${msg}`
+        });
+        continue;
+      }
+      const prompt = buildSpecGenerationPrompt(resolvedPath, phaseFile, content);
+      let toolCalls = 0;
+      let fileCost = 0;
+      try {
+        log?.info({ file: rel }, "Starting spec generation session");
+        const sessionResult = await adapter.sendAndWait(handle, {
+          sessionId,
+          message: prompt,
+          stallMs: 5 * 60 * 1e3,
+          // 5 min stall — per-file scope is smaller
+          onToolCall: (toolName, firstArg) => {
+            toolCalls++;
+            log?.debug({ file: rel, toolName, firstArg, toolCalls }, "Spec generation tool call");
+            emitter?.emitEvent({
+              type: "tool:call",
+              timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+              toolName,
+              ...firstArg ? { firstArg } : {},
+              iteration: 0
+            });
+          },
+          onTextDelta: () => {
+          },
+          onCostUpdate: (cost, tokens) => {
+            fileCost = cost;
+            emitter?.emitEvent({
+              type: "cost:update",
+              timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+              cumulativeCostUsd: cost,
+              isEstimated: false,
+              iteration: 0,
+              tokensIn: tokens.input,
+              tokensOut: tokens.output
+            });
+          }
+        });
+        if (sessionResult.kind === "error") {
+          const rawMsg = "message" in sessionResult ? sessionResult.message : "unknown error";
+          const errMsg = adapter.enhanceError ? await adapter.enhanceError(rawMsg) : rawMsg;
+          log?.error({ file: rel, err: errMsg }, "Session errored");
+          emitter?.emitEvent({
+            type: "enrich:file:error",
+            timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+            file: rel,
+            error: errMsg
+          });
+          continue;
+        }
+        if (sessionResult.kind === "stall") {
+          log?.error({ file: rel }, "Session stalled");
+          emitter?.emitEvent({
+            type: "enrich:file:error",
+            timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+            file: rel,
+            error: "session stalled"
+          });
+          continue;
+        }
+        const response = await adapter.getLastResponse(handle, sessionId);
+        log?.debug({ file: rel, toolCalls, responseLength: response.length }, "Session response received");
+        if (adapter.getSessionStats) {
+          try {
+            const stats = await adapter.getSessionStats(handle, sessionId);
+            enrichmentCumulativeCost += stats.cost;
+            if (enrichmentCumulativeCost > 0 || stats.tokensIn > 0 || stats.tokensOut > 0) {
+              emitter?.emitEvent({
+                type: "cost:update",
+                timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+                cumulativeCostUsd: enrichmentCumulativeCost,
+                isEstimated: false,
+                iteration: 0,
+                tokensIn: stats.tokensIn,
+                tokensOut: stats.tokensOut
+              });
+            }
+          } catch {
+          }
+        }
+        if (!response.includes("SPEC_COMPLETE")) {
+          log?.warn({ file: rel, toolCalls }, "Spec generation session did not complete cleanly");
+          emitter?.emitEvent({
+            type: "enrich:file:error",
+            timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+            file: rel,
+            error: "spec generation session did not complete cleanly"
+          });
+        } else if (specPath && !fs.existsSync(specPath)) {
+          log?.warn({ file: rel, toolCalls }, "Spec generation session did not complete cleanly");
+          emitter?.emitEvent({
+            type: "enrich:file:error",
+            timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+            file: rel,
+            error: `SPEC_COMPLETE received but spec/${specFileName} was not written`
+          });
+        } else {
+          log?.info({ file: rel, toolCalls }, "Spec generated successfully");
+          emitter?.emitEvent({
+            type: "enrich:file:done",
+            timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+            file: rel,
+            toolCalls,
+            ...specPath ? { specFile: `spec/${specFileName}` } : {}
+          });
+        }
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        log?.error({ file: rel, err: msg, toolCalls }, "Spec generation failed \u2014 continuing");
+        emitter?.emitEvent({
+          type: "enrich:file:error",
+          timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+          file: rel,
+          error: `spec generation failed: ${msg}`
+        });
+      }
+    }
+  } finally {
+    await adapter.shutdown(handle);
+  }
+  if (savedCompletionStates && savedCompletionStates.size > 0) {
+    try {
+      const mainYamlPath = path.join(resolvedPath, "spec", "main.yaml");
+      if (fs.existsSync(mainYamlPath)) {
+        let content = fs.readFileSync(mainYamlPath, "utf-8");
+        const raw = yamlParse(content);
+        if (raw && Array.isArray(raw.phases)) {
+          let modified = false;
+          for (const phase of raw.phases) {
+            if (phase.file && savedCompletionStates.has(phase.file) && phase.completed !== true) {
+              phase.completed = true;
+              modified = true;
+            }
+          }
+          if (modified) {
+            fs.writeFileSync(mainYamlPath, yamlStringify(raw), "utf-8");
+            log?.info({ restored: savedCompletionStates.size }, "Restored phase completion states after enrichment");
+          }
+        }
+      }
+    } catch (err) {
+      log?.warn({ err }, "Failed to restore phase completion states \u2014 phases may need manual re-marking");
+    }
+  }
+  emitter?.emitEvent({
+    type: "enrich:done",
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    filesProcessed: planFiles.length
+  });
+}
+
+export {
+  ENRICHMENT_RATIO_THRESHOLD,
+  computeEnrichmentRatio,
+  computeSpecEnrichmentRatio,
+  enrichPlanForFastModel
+};