@usezombie/zombiectl 0.3.0

package/src/commands/harness_source.js

@@ -0,0 +1,72 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { queueCliAnalyticsEvent, setCliAnalyticsContext } from "../lib/analytics.js";
+
+export async function commandHarnessSourcePut(ctx, parsed, workspaceId, deps) {
+  const {
+    request,
+    apiHeaders,
+    ui,
+    printJson,
+    printKeyValue = () => {},
+    printSection = () => {},
+    writeLine,
+    readFile = fs.readFile,
+    resolvePath = path.resolve,
+  } = deps;
+
+  const file = parsed.options.file;
+  if (!file) {
+    writeLine(ctx.stderr, ui.err("harness source put requires --file"));
+    return 2;
+  }
+
+  const fileContent = await readFile(resolvePath(file), "utf8");
+
+  const MAX_SIZE = 2 * 1024 * 1024;
+  const sizeBytes = Buffer.byteLength(fileContent, "utf8");
+  if (sizeBytes > MAX_SIZE) {
+    writeLine(ctx.stderr, ui.err(`file too large: ${sizeBytes} bytes (max 2MB)`));
+    return 2;
+  }
+
+  if (!ctx.jsonMode) {
+    writeLine(ctx.stdout, ui.info(`uploading ${path.basename(String(file))} (${sizeBytes} bytes)`));
+  }
+
+  const inferredName = path.basename(String(file), path.extname(String(file)));
+  const body = {
+    agent_id: parsed.options["agent-id"] || null,
+    name: parsed.options.name || inferredName || "Workspace Harness",
+    source_markdown: fileContent,
+  };
+
+  const res = await request(ctx, `/v1/workspaces/${encodeURIComponent(workspaceId)}/harness/source`, {
+    method: "PUT",
+    headers: apiHeaders(ctx),
+    body: JSON.stringify(body),
+  });
+
+  setCliAnalyticsContext(ctx, {
+    workspace_id: workspaceId,
+    agent_id: body.agent_id,
+    harness_name: body.name,
+    harness_config_version_id: res.config_version_id,
+    harness_source_bytes: sizeBytes,
+  });
+  queueCliAnalyticsEvent(ctx, "harness_source_uploaded", {
+    workspace_id: workspaceId,
+    harness_config_version_id: res.config_version_id,
+  });
+  if (ctx.jsonMode) printJson(ctx.stdout, res);
+  else {
+    printSection(ctx.stdout, "Harness source stored");
+    printKeyValue(ctx.stdout, {
+      workspace_id: workspaceId,
+      config_version_id: res.config_version_id,
+      name: body.name,
+      size_bytes: sizeBytes,
+    });
+  }
+  return 0;
+}

package/src/commands/run_preview.js

@@ -0,0 +1,212 @@
+import { readFileSync, existsSync } from "node:fs";
+import { resolve, relative } from "node:path";
+import { agentLoop } from "../lib/agent-loop.js";
+
+// Confidence display config: icon (TTY) + bracket label (no-TTY) + ANSI code
+const CONF_DISPLAY = {
+  high:   { ansi: "32", icon: "\u{25CF}", label: "[HIGH]" },  // green
+  medium: { ansi: "33", icon: "\u{25C6}", label: "[MED] " },  // yellow
+  low:    { ansi:  "2", icon: "\u{25CB}", label: "[LOW] " },  // dim
+};
+
+/**
+ * Returns the confidence indicator string appropriate for the output stream.
+ * TTY -> colored Unicode icon. Non-TTY / NO_COLOR -> plain text label.
+ */
+export function confIndicator(confidence, stream) {
+  const d = CONF_DISPLAY[confidence] ?? CONF_DISPLAY.low;
+  const noColor = Boolean(process.env.NO_COLOR) || !stream?.isTTY;
+  if (noColor) return d.label;
+  return `\u001b[${d.ansi}m${d.icon}\u001b[0m`;
+}
+
+/**
+ * Strip ANSI escape sequences from a string.
+ */
+export function sanitizeDisplay(str) {
+  // eslint-disable-next-line no-control-regex
+  return str.replace(/\x1b\[[0-9;]*m/g, "").replace(/[\x00-\x08\x0b\x0c\x0e-\x1f\x7f]/g, "");
+}
+
+/**
+ * Print the predicted impact list.
+ */
+const PREVIEW_TITLE = "Predicted file impact";
+
+export function printPreview(stdout, matches, { writeLine, ui }) {
+  if (matches.length === 0) {
+    writeLine(stdout, ui.info("no file references detected in spec"));
+    return;
+  }
+
+  writeLine(stdout, ui.head(PREVIEW_TITLE));
+  writeLine(stdout, ui.dim("\u2500".repeat(PREVIEW_TITLE.length)));
+  writeLine(stdout);
+
+  for (const { file, confidence } of matches) {
+    const indicator = confIndicator(confidence, stdout);
+    writeLine(stdout, `  ${indicator}  ${sanitizeDisplay(file)}`);
+  }
+  writeLine(stdout);
+  writeLine(stdout, ui.dim(`  ${matches.length} file(s) in blast radius`));
+}
+
+/**
+ * Parse agent text output into structured matches.
+ * Expected format: "● src/file.go  high  — reason" or similar.
+ */
+function parseAgentMatches(text) {
+  const matches = [];
+  const lineRe = /^[●◆○\s]*(\S+)\s+(high|medium|low)/gm;
+  let m;
+  while ((m = lineRe.exec(text)) !== null) {
+    matches.push({ file: m[1], confidence: m[2] });
+  }
+  return matches;
+}
+
+/**
+ * Run preview using agent relay: agent reads spec + explores repo.
+ * Returns { matches } or null on error.
+ */
+export async function runPreview(specFile, repoPath, ctx, deps) {
+  const { writeLine, ui } = deps;
+
+  if (!existsSync(specFile)) {
+    writeLine(ctx.stderr, ui.err(`spec file not found: ${specFile}`));
+    return null;
+  }
+
+  let markdown;
+  try {
+    markdown = readFileSync(specFile, "utf8");
+  } catch (err) {
+    writeLine(ctx.stderr, ui.err(`failed to read spec file: ${err.message}`));
+    return null;
+  }
+
+  const absRepoPath = resolve(repoPath);
+
+  // If workspace is available, use agent-backed preview
+  if (ctx.workspaceId) {
+    return agentPreview(markdown, absRepoPath, ctx, deps);
+  }
+
+  // Fallback: local heuristic preview (legacy, kept for offline use)
+  return localPreview(markdown, absRepoPath, ctx, deps);
+}
+
+async function agentPreview(markdown, repoPath, ctx, deps) {
+  const { writeLine, ui } = deps;
+  const endpoint = `/v1/workspaces/${ctx.workspaceId}/spec/preview`;
+
+  if (!ctx.jsonMode) {
+    writeLine(ctx.stdout, "");
+    writeLine(ctx.stdout, ui.dim("  \u{1F9DF} analyzing your repo against spec..."));
+  }
+
+  const result = await agentLoop(
+    endpoint,
+    `Which files will this spec touch?\n\n${markdown}`,
+    repoPath,
+    ctx,
+    {
+      onToolCall: (tc) => {
+        if (!ctx.jsonMode) {
+          const label = tc.name === "read_file" ? `read ${tc.input.path}`
+            : tc.name === "list_dir" ? `listed ${tc.input.path || "./"}`
+            : `glob ${tc.input.pattern}`;
+          writeLine(ctx.stdout, ui.dim(`  \u{2192} ${label}`));
+        }
+      },
+      onError: (msg) => {
+        writeLine(ctx.stderr, ui.err(msg));
+      },
+    },
+  );
+
+  if (!result.text) {
+    writeLine(ctx.stderr, ui.err("agent returned no content"));
+    return null;
+  }
+
+  const matches = parseAgentMatches(result.text);
+  if (!ctx.jsonMode) {
+    writeLine(ctx.stdout, "");
+    printPreview(ctx.stdout, matches, deps);
+    const secs = (result.wallMs / 1000).toFixed(1);
+    const tokens = result.usage?.total_tokens ?? "?";
+    writeLine(ctx.stdout, ui.dim(`    ${secs}s | ${result.toolCalls} reads | ${tokens} tokens`));
+  }
+
+  return { matches };
+}
+
+/**
+ * Local heuristic preview — kept for offline/no-auth scenarios.
+ * Uses regex to extract file refs from spec and match against repo tree.
+ */
+async function localPreview(markdown, repoPath, ctx, deps) {
+  const { walkDirForPreview } = await import("./run_preview_walk.js");
+
+  const refs = extractSpecRefs(markdown);
+  const repoFiles = walkDirForPreview(repoPath);
+  const relFiles = repoFiles.map((f) => relative(repoPath, f).replace(/\\/g, "/"));
+  const matches = matchRefsToFiles(refs, relFiles);
+  printPreview(ctx.stdout, matches, deps);
+  return { matches };
+}
+
+// ── Legacy heuristic functions (used by localPreview fallback) ──────────────
+
+export function extractSpecRefs(markdown) {
+  const refs = new Set();
+  const quotedRe = /["`']([a-zA-Z0-9_./-]{3,}[/.][a-zA-Z0-9_/-]+)["`']/g;
+  for (const m of markdown.matchAll(quotedRe)) refs.add(m[1]);
+  const prefixRe = /\b((?:src|tests?|lib|pkg|cmd|internal|docs|app|web|api|workers?|scripts?)\/[a-zA-Z0-9_./-]+)/g;
+  for (const m of markdown.matchAll(prefixRe)) refs.add(m[1]);
+  const fileRe = /\b([a-zA-Z0-9_-]+\.(?:go|rs|ts|tsx|js|mjs|py|zig|rb|java|kt|c|cpp|cs|swift|ex|exs|sh|yaml|yml|toml|json|md))\b/g;
+  for (const m of markdown.matchAll(fileRe)) refs.add(m[1]);
+  return [...refs];
+}
+
+function scoreMatch(filePath, ref) {
+  const fp = filePath.replace(/\\/g, "/");
+  const r = ref.replace(/\\/g, "/");
+  if (fp.endsWith(r) || fp === r) return "high";
+  const refParts = r.split("/").filter(Boolean);
+  const fileParts = fp.split("/").filter(Boolean);
+  if (refParts.length >= 2) {
+    const refStr = refParts.join("/");
+    if (fp.includes(refStr)) return "medium";
+  }
+  if (refParts.length === 1) {
+    const name = fileParts[fileParts.length - 1];
+    if (name === refParts[0]) return "medium";
+    if (name.startsWith(refParts[0]) || fp.includes(`/${refParts[0]}/`)) return "low";
+  }
+  if (fp.includes(r)) return "low";
+  return null;
+}
+
+const CONFIDENCE_ORDER = { high: 0, medium: 1, low: 2 };
+
+export function matchRefsToFiles(refs, repoFiles) {
+  const best = new Map();
+  for (const ref of refs) {
+    for (const file of repoFiles) {
+      const conf = scoreMatch(file, ref);
+      if (!conf) continue;
+      const existing = best.get(file);
+      if (!existing || CONFIDENCE_ORDER[conf] < CONFIDENCE_ORDER[existing]) {
+        best.set(file, conf);
+      }
+    }
+  }
+  return [...best.entries()]
+    .map(([file, confidence]) => ({ file, confidence }))
+    .sort((a, b) => {
+      const cmp = CONFIDENCE_ORDER[a.confidence] - CONFIDENCE_ORDER[b.confidence];
+      return cmp !== 0 ? cmp : a.file.localeCompare(b.file);
+    });
+}

package/src/commands/run_preview_walk.js

@@ -0,0 +1 @@
+export { walkDir as walkDirForPreview } from "../lib/walk-dir.js";

package/src/commands/runs.js

@@ -0,0 +1,35 @@
+// M17_001 §3: zombiectl runs cancel <run_id>
+
+function commandRuns(ctx, args, deps) {
+  const { parseFlags, printJson, request, apiHeaders, ui, writeLine } = deps;
+
+  async function cancel(subArgs) {
+    const parsed = parseFlags(subArgs);
+    const runId = parsed.positionals[0];
+    if (!runId) {
+      writeLine(ctx.stderr, ui.err("usage: zombiectl runs cancel <run_id>"));
+      return 2;
+    }
+
+    const result = await request(ctx, `/v1/runs/${encodeURIComponent(runId)}:cancel`, {
+      method: "POST",
+      headers: apiHeaders(ctx),
+    });
+
+    if (ctx.jsonMode) {
+      printJson(ctx.stdout, result);
+    } else {
+      writeLine(ctx.stdout, ui.ok(`Run ${runId} cancel requested`));
+    }
+    return 0;
+  }
+
+  const action = args[0];
+  if (action === "cancel") return cancel(args.slice(1));
+
+  writeLine(ctx.stderr, ui.err(`unknown runs subcommand: ${action}`));
+  writeLine(ctx.stderr, ui.err("available: cancel"));
+  return Promise.resolve(2);
+}
+
+export { commandRuns };

package/src/commands/spec_init.js

@@ -0,0 +1,287 @@
+import { readFileSync, existsSync, statSync, writeFileSync, mkdirSync } from "node:fs";
+import { join, dirname, resolve } from "node:path";
+import { walkDir } from "../lib/walk-dir.js";
+import { agentLoop } from "../lib/agent-loop.js";
+
+/**
+ * Parse Makefile and return list of target names.
+ */
+export function parseMakeTargets(repoPath) {
+  const makefile = join(repoPath, "Makefile");
+  if (!existsSync(makefile)) return [];
+
+  let content;
+  try {
+    content = readFileSync(makefile, "utf8");
+  } catch {
+    return [];
+  }
+
+  const targets = new Set();
+  for (const line of content.split("\n")) {
+    const m = line.match(/^([a-zA-Z][a-zA-Z0-9_.-]*)\s*:/);
+    if (m && !m[1].startsWith(".")) targets.add(m[1]);
+  }
+  return [...targets];
+}
+
+/**
+ * Detect test patterns from file paths.
+ */
+export function detectTestPatterns(files) {
+  const patterns = new Set();
+  for (const f of files) {
+    const base = f.replace(/\\/g, "/");
+    if (/(^|\/)tests?\//.test(base)) patterns.add("tests/ directory");
+    if (/\.(test|spec)\.[a-z]+$/.test(base)) patterns.add("*.test.* / *.spec.*");
+    if (/_test\.[a-z]+$/.test(base)) patterns.add("*_test.*");
+    if (/\.test\.[a-z]+$/.test(base)) patterns.add("*.test.*");
+  }
+  return [...patterns];
+}
+
+/**
+ * Detect project structure indicators.
+ */
+export function detectProjectStructure(repoPath) {
+  const indicators = [];
+  for (const dir of ["src", "tests", "test", "docs", "lib", "pkg", "cmd", "internal"]) {
+    if (existsSync(join(repoPath, dir))) indicators.push(`${dir}/`);
+  }
+  return indicators;
+}
+
+/**
+ * Scan a repo and return detected context.
+ */
+export function scanRepo(repoPath) {
+  const files = walkDir(repoPath);
+  return {
+    makeTargets: parseMakeTargets(repoPath),
+    testPatterns: detectTestPatterns(files),
+    projectStructure: detectProjectStructure(repoPath),
+    fileCount: files.length,
+  };
+}
+
+/**
+ * commandSpecInit: implement `zombiectl spec init [--path DIR] [--output PATH] [--describe TEXT]`
+ *
+ * With --describe: uses agent relay to generate a spec from intent (requires auth).
+ * Without --describe: falls back to local template generation (no auth required).
+ */
+export async function commandSpecInit(args, ctx, deps) {
+  const { parseFlags, writeLine, ui } = deps;
+  const parsed = parseFlags(args);
+  const repoPath = resolve(parsed.options.path || ".");
+  const outputPath = parsed.options.output || "docs/spec/new-feature.md";
+  const describe = parsed.options.describe;
+
+  if (!existsSync(repoPath)) {
+    writeLine(ctx.stderr, ui.err(`path not found: ${repoPath}`));
+    return 2;
+  }
+  if (!statSync(repoPath).isDirectory()) {
+    writeLine(ctx.stderr, ui.err(`path is not a directory: ${repoPath}`));
+    return 2;
+  }
+
+  // Agent-backed generation when --describe is provided
+  if (describe && ctx.workspaceId) {
+    return agentSpecInit(describe, repoPath, outputPath, ctx, deps);
+  }
+
+  // Fallback: local template generation (no auth required)
+  return localSpecInit(repoPath, outputPath, ctx, deps);
+}
+
+async function agentSpecInit(describe, repoPath, outputPath, ctx, deps) {
+  const { writeLine, ui, printJson } = deps;
+  const endpoint = `/v1/workspaces/${ctx.workspaceId}/spec/template`;
+
+  if (!ctx.jsonMode) {
+    writeLine(ctx.stdout, "");
+    writeLine(ctx.stdout, ui.dim("  \u{1F9DF} analyzing your repo..."));
+  }
+
+  const result = await agentLoop(endpoint, `Generate a spec template for: ${describe}`, repoPath, ctx, {
+    onToolCall: (tc) => {
+      if (!ctx.jsonMode) {
+        const label = tc.name === "read_file" ? `read ${tc.input.path}`
+          : tc.name === "list_dir" ? `listed ${tc.input.path || "./"}`
+          : `glob ${tc.input.pattern}`;
+        writeLine(ctx.stdout, ui.dim(`  \u{2192} ${label}`));
+      }
+    },
+    onError: (msg) => {
+      writeLine(ctx.stderr, ui.err(msg));
+    },
+  });
+
+  if (!result.text) {
+    writeLine(ctx.stderr, ui.err("agent returned no content"));
+    return 1;
+  }
+
+  if (!ctx.jsonMode) {
+    writeLine(ctx.stdout, "");
+    writeLine(ctx.stdout, ui.dim("  \u{1F9DF} drafting spec..."));
+  }
+
+  const outDir = dirname(outputPath);
+  try {
+    mkdirSync(outDir, { recursive: true });
+    writeFileSync(outputPath, result.text, "utf8");
+  } catch (err) {
+    writeLine(ctx.stderr, ui.err(`failed to write spec: ${err.message}`));
+    return 1;
+  }
+
+  if (ctx.jsonMode) {
+    printJson(ctx.stdout, {
+      output: outputPath,
+      tool_calls: result.toolCalls,
+      wall_ms: result.wallMs,
+      usage: result.usage,
+    });
+  } else {
+    writeLine(ctx.stdout, "");
+    writeLine(ctx.stdout, ui.ok(`\u{2713} wrote ${outputPath}`));
+    const secs = (result.wallMs / 1000).toFixed(1);
+    const tokens = result.usage?.total_tokens ?? "?";
+    writeLine(ctx.stdout, ui.dim(`    ${secs}s | ${result.toolCalls} reads | ${tokens} tokens`));
+  }
+
+  return 0;
+}
+
+function localSpecInit(repoPath, outputPath, ctx, deps) {
+  const { writeLine, ui, printJson } = deps;
+  const scan = scanRepo(repoPath);
+  const template = generateTemplate(scan);
+
+  const outDir = dirname(outputPath);
+  try {
+    mkdirSync(outDir, { recursive: true });
+    writeFileSync(outputPath, template, "utf8");
+  } catch (err) {
+    writeLine(ctx.stderr, ui.err(`failed to write template: ${err.message}`));
+    return 1;
+  }
+
+  if (ctx.jsonMode) {
+    printJson(ctx.stdout, {
+      output: outputPath,
+      detected: {
+        make_targets: scan.makeTargets,
+        test_patterns: scan.testPatterns,
+        project_structure: scan.projectStructure,
+        file_count: scan.fileCount,
+      },
+    });
+  } else {
+    writeLine(ctx.stdout, ui.ok(`template written \u{2192} ${outputPath}`));
+    writeLine(ctx.stdout);
+    const rows = [];
+    if (scan.makeTargets.length > 0)      rows.push(["make targets", scan.makeTargets.join(", ")]);
+    if (scan.testPatterns.length > 0)     rows.push(["test patterns", scan.testPatterns.join(", ")]);
+    if (scan.projectStructure.length > 0) rows.push(["structure",     scan.projectStructure.join("  ")]);
+    if (rows.length > 0) {
+      const w = Math.max(...rows.map(([k]) => k.length));
+      const sep = ui.dim("  \u{00B7}  ");
+      for (const [k, v] of rows) {
+        writeLine(ctx.stdout, `  ${ui.dim(k.padEnd(w))}${sep}${v}`);
+      }
+      writeLine(ctx.stdout);
+    }
+    writeLine(ctx.stdout, ui.dim(`${scan.fileCount} file(s) scanned`));
+  }
+
+  return 0;
+}
+
+function currentDateStr() {
+  const d = new Date();
+  const months = ["Jan","Feb","Mar","Apr","May","Jun","Jul","Aug","Sep","Oct","Nov","Dec"];
+  return `${months[d.getMonth()]} ${String(d.getDate()).padStart(2,"0")}, ${d.getFullYear()}`;
+}
+
+/**
+ * Generate a spec template markdown string from scan results.
+ */
+export function generateTemplate(scan) {
+  const { makeTargets, testPatterns, projectStructure } = scan;
+
+  const GATE_TARGETS = new Set(["lint","test","build","check","fmt","format","verify","qa","qa-smoke"]);
+  const detectedGates = makeTargets.filter((t) => GATE_TARGETS.has(t));
+
+  const gatesBlock = detectedGates.length > 0
+    ? detectedGates.map((t) => `- \`make ${t}\``).join("\n")
+    : "- _(no Makefile gates detected)_";
+
+  const structureBlock = projectStructure.length > 0
+    ? projectStructure.map((d) => `- \`${d}\``).join("\n")
+    : "- _(empty or minimal repo)_";
+
+  return `# M{N}_001: {Feature Title}
+
+**Prototype:** v1.0.0
+**Milestone:** M{N}
+**Workstream:** 001
+**Date:** ${currentDateStr()}
+**Status:** PENDING
+**Priority:** P1 \u{2014} {one-line description of what this workstream delivers}
+**Batch:** B1
+**Depends on:** \u{2014}
+
+---
+
+## 1.0 Implementation
+
+**Status:** PENDING
+
+Implement the feature below.
+
+**Detected project structure:**
+${structureBlock}
+
+**Dimensions:**
+- 1.1 PENDING {First implementation step}
+- 1.2 PENDING {Second implementation step}
+- 1.3 PENDING {Write or update tests}
+- 1.4 PENDING {Handle edge cases}
+
+---
+
+## 2.0 Verification
+
+**Status:** PENDING
+
+**Detected gates:**
+${gatesBlock}
+
+**Test patterns detected:** ${testPatterns.length > 0 ? testPatterns.join(", ") : "none"}
+
+**Dimensions:**
+- 2.1 PENDING All detected gates pass
+- 2.2 PENDING New tests cover the feature path
+- 2.3 PENDING No regressions in existing tests
+
+---
+
+## 3.0 Acceptance Criteria
+
+**Status:** PENDING
+
+- [ ] 3.1 {Primary success criterion}
+- [ ] 3.2 {Secondary success criterion}
+- [ ] 3.3 All detected gates pass with no new failures
+
+---
+
+## 4.0 Out of Scope
+
+- {Item not in scope}
+- {Another out of scope item}
+`;
+}

package/src/commands/workspace_billing.js

@@ -0,0 +1,26 @@
+export async function commandWorkspaceUpgradeScale(ctx, parsed, workspaceId, deps) {
+  const { request, apiHeaders, ui, printJson, writeLine } = deps;
+  const subscriptionId = parsed.options["subscription-id"] || parsed.positionals[1];
+
+  if (!subscriptionId) {
+    writeLine(ctx.stderr, ui.err("workspace upgrade-scale requires --subscription-id"));
+    return 2;
+  }
+
+  const res = await request(ctx, `/v1/workspaces/${encodeURIComponent(workspaceId)}/billing/scale`, {
+    method: "POST",
+    headers: apiHeaders(ctx),
+    body: JSON.stringify({ subscription_id: subscriptionId }),
+  });
+
+  if (ctx.jsonMode) {
+    printJson(ctx.stdout, res);
+  } else {
+    writeLine(ctx.stdout, ui.ok(`workspace upgraded to ${res.plan_tier}`));
+    writeLine(ctx.stdout, `workspace_id: ${workspaceId}`);
+    writeLine(ctx.stdout, `plan_tier: ${res.plan_tier}`);
+    writeLine(ctx.stdout, `billing_status: ${res.billing_status}`);
+    if (res.subscription_id != null) writeLine(ctx.stdout, `subscription_id: ${res.subscription_id}`);
+  }
+  return 0;
+}

package/src/constants/error-codes.js

@@ -0,0 +1 @@
+export const ERR_BILLING_CREDIT_EXHAUSTED = "UZ-BILLING-005";