@aipper/aiws 0.0.28 → 0.0.29

package/src/commands/init.js

@@ -77,6 +77,14 @@ export async function initCommand(options) {
     await copyTemplateFileToWorkspace({ templateDir: tpl.templateDir, workspaceRoot, relPosix: r });
   }
 
+  // Ensure replace_file-only entries (not listed in required/optional) are also copied
+  for (const r of replaceFiles) {
+    if (!r || r === ".aiws/manifest.json") continue;
+    const dest = joinRel(workspaceRoot, r);
+    if (await pathExists(dest)) continue;
+    await copyTemplateFileToWorkspace({ templateDir: tpl.templateDir, workspaceRoot, relPosix: r });
+  }
+
   const now = new Date().toISOString().replace(/\.\d{3}Z$/, "Z");
   await writeWorkspaceManifest({
     workspaceRoot,

package/src/commands/opencode-auto.js

@@ -0,0 +1,167 @@
+import path from "node:path";
+import { UserError } from "../errors.js";
+import { pathExists, readText } from "../fs.js";
+import { loadAiwsPackage } from "../aiws-package.js";
+import { loadTemplate } from "../spec.js";
+import { resolveWorkspaceRoot } from "../workspace.js";
+import { updateCommand } from "./update.js";
+import { detectOpenCodeEnvironment } from "../opencode-env.js";
+import { ensureOpenCodeWatchdog, tmuxInstalled } from "./opencode-supervise.js";
+
+const REQUIRED_TRUTH_FILES = ["AI_PROJECT.md", "REQUIREMENTS.md", "AI_WORKSPACE.md"];
+const REQUIRED_AUTONOMY_FILES = [
+  ".opencode/oh-my-opencode.json.example",
+  ".claude/settings.json.example",
+  ".opencode/helpers/approval-whitelist-check.sh",
+  ".opencode/helpers/approval-whitelist-run.sh",
+  ".opencode/helpers/approval-whitelist-watchdog.sh",
+  ".opencode/helpers/tmux-swarm-scan.sh",
+  ".opencode/helpers/tmux-swarm-rescue.sh",
+  ".opencode/skills/ws-autonomy/SKILL.md",
+  ".opencode/commands/ws-autonomy.md",
+  ".opencode/command/ws-autonomy.md",
+  ".opencode/skills/ws-auto/SKILL.md",
+  ".opencode/commands/ws-auto.md",
+  ".opencode/command/ws-auto.md",
+];
+
+async function collectMissingPaths(workspaceRoot, relPaths) {
+  /** @type {string[]} */
+  const missing = [];
+  for (const rel of relPaths) {
+    if (!(await pathExists(path.join(workspaceRoot, rel)))) {
+      missing.push(rel);
+    }
+  }
+  return missing;
+}
+
+async function readWorkspaceManifest(workspaceRoot) {
+  const manifestPath = path.join(workspaceRoot, ".aiws", "manifest.json");
+  if (!(await pathExists(manifestPath))) {
+    throw new UserError("Missing .aiws/manifest.json. Run `aiws init .` first.");
+  }
+  return JSON.parse(await readText(manifestPath));
+}
+
+/**
+ * @param {string} workspaceRoot
+ */
+async function detectAutoBootstrapState(workspaceRoot) {
+  const env = await detectOpenCodeEnvironment(workspaceRoot);
+  const manifest = await readWorkspaceManifest(workspaceRoot);
+  const templateId = String(manifest.template_id || "workspace");
+  const tpl = await loadTemplate(templateId);
+  const aiws = await loadAiwsPackage();
+  const truthMissing = await collectMissingPaths(workspaceRoot, REQUIRED_TRUTH_FILES);
+  const autonomyMissing = await collectMissingPaths(workspaceRoot, REQUIRED_AUTONOMY_FILES);
+
+  /** @type {string[]} */
+  const updateReasons = [];
+  if (autonomyMissing.length > 0) {
+    updateReasons.push(`autonomy_files_missing=${autonomyMissing.join(",")}`);
+  }
+  if (String(manifest.spec_version || "") !== String(tpl.specVersion || "")) {
+    updateReasons.push(`spec_version=${String(manifest.spec_version || "(missing)")}->${String(tpl.specVersion || "(missing)")}`);
+  }
+  if (String(manifest.aiws_version || "") !== String(aiws.version || "")) {
+    updateReasons.push(`aiws_version=${String(manifest.aiws_version || "(missing)")}->${String(aiws.version || "(missing)")}`);
+  }
+
+  return {
+    env,
+    manifest,
+    truthMissing,
+    autonomyMissing,
+    updateRequired: updateReasons.length > 0,
+    updateReasons,
+  };
+}
+
+/**
+ * @param {{
+ *   targetPath: string,
+ *   sessionName?: string,
+ *   windowName?: string,
+ *   once?: boolean,
+ *   pollMs?: string,
+ *   noUpdate?: boolean,
+ * }} options
+ */
+export async function opencodeAutoCommand(options) {
+  const workspaceRoot = await resolveWorkspaceRoot(options.targetPath, { create: false });
+  let state = await detectAutoBootstrapState(workspaceRoot);
+  let updateApplied = false;
+
+  console.log(`✓ aiws opencode auto: ${workspaceRoot}`);
+  console.log(`found_truth: ${state.truthMissing.length === 0 ? REQUIRED_TRUTH_FILES.join(", ") : "(incomplete)"}`);
+
+  if (state.truthMissing.length > 0) {
+    console.log(`update: skipped (missing truth files: ${state.truthMissing.join(", ")})`);
+    console.log(`mode: ${state.env.mode}`);
+    console.log(`watchdog: skipped (missing truth files: ${state.truthMissing.join(", ")})`);
+    console.log("next: 先补齐真值文件，再重新运行 `aiws opencode auto .` 或 `/ws-preflight`。");
+    return;
+  }
+
+  if (state.updateRequired && options.noUpdate !== true) {
+    console.log(`update: required (${state.updateReasons.join("; ")})`);
+    await updateCommand({ targetPath: workspaceRoot });
+    updateApplied = true;
+    state = await detectAutoBootstrapState(workspaceRoot);
+  } else if (state.updateRequired) {
+    console.log(`update: required but skipped (--no-update)`);
+    console.log(`update_reasons: ${state.updateReasons.join("; ")}`);
+  } else {
+    console.log("update: not needed");
+  }
+
+  console.log(`mode: ${state.env.mode}`);
+  if (updateApplied) {
+    console.log("update_applied: true");
+  }
+
+  if (state.env.configStatus === "invalid") {
+    console.log(`watchdog: skipped (invalid config: ${state.env.rel.configPath})`);
+    console.log(`next: 修复 ${state.env.rel.configPath} 的 JSON，然后重新运行 \`aiws opencode auto .\`.`);
+    return;
+  }
+  if (!state.env.configExists) {
+    console.log("watchdog: skipped (oMo config missing)");
+    console.log(`next: 如需启用 autonomous bootstrap，可复制 ${state.env.rel.examplePath} -> ${state.env.rel.configPath}，然后重新运行 \`aiws opencode auto .\`.`);
+    return;
+  }
+  if (!state.env.watchdogSuperviseReady) {
+    console.log("watchdog: skipped (approval/watchdog chain incomplete)");
+    console.log("next: 先运行 `aiws opencode status .` 查看缺哪一项；如是托管文件缺失，可运行 `aiws update .`。");
+    return;
+  }
+  if (!tmuxInstalled()) {
+    console.log("watchdog: skipped (tmux missing)");
+    console.log("next: 安装 tmux 后重新运行 `aiws opencode auto .`，或手工执行 approval-whitelist-watchdog helper。");
+    return;
+  }
+
+  const ensureResult = ensureOpenCodeWatchdog({
+    workspaceRoot,
+    env: state.env,
+    sessionName: options.sessionName,
+    windowName: options.windowName,
+    once: options.once === true,
+    pollMs: options.pollMs ?? null,
+  });
+  console.log(`watchdog: ${ensureResult.state}`);
+  console.log(`tmux session: ${ensureResult.sessionName}${ensureResult.currentSession ? " (current)" : ""}`);
+  console.log(`watchdog window: ${ensureResult.windowName}`);
+  console.log(`watchdog helper: ${ensureResult.helperRelPath}`);
+  if (ensureResult.once) {
+    console.log("watchdog_mode: once");
+  } else {
+    console.log(`watchdog_mode: loop${ensureResult.pollMs !== null ? ` (poll_ms=${ensureResult.pollMs})` : ""}`);
+  }
+  if (state.env.autonomyReady) {
+    console.log("next: watchdog 已就绪，可继续 `/ws-auto` -> `/using-aiws` / `/ws-plan` / `/ws-autonomy`。");
+    return;
+  }
+  console.log("next: watchdog 已启动，但 autonomy contract 尚未完整；建议先运行 `aiws opencode status .` 或 `/ws-autonomy` 查看缺口。");
+}

package/src/commands/opencode-status.js

@@ -39,22 +39,64 @@ export async function opencodeStatusCommand(options) {
 
   if (planner.present) {
     console.log(`planner-sisyphus.replace_plan: ${planner.replacePlan === null ? "(unset)" : String(planner.replacePlan)}`);
+    console.log(`planner-sisyphus.prompt_append: ${planner.promptAppendConfigured ? "configured" : "missing"}`);
   }
+  console.log(`background_tasks: ${env.backgroundTasksConfigured ? "configured" : "missing"}`);
+  console.log(`auto_resume: ${env.autoResumeEnabled ? "true" : "false"}`);
+  console.log(
+    `approval_whitelist: ${
+      env.approvalWhitelist.present
+        ? env.approvalWhitelist.configured
+          ? `configured (${env.approvalWhitelist.mode || "unset"})`
+          : "incomplete"
+        : "missing"
+    }`,
+  );
+  console.log(`host_permission_mode: ${env.approvalWhitelist.hostPermissionMode || "missing"}`);
+  console.log(
+    `approval_helper: ${env.approvalWhitelistHelperExists ? `${env.rel.approvalWhitelistHelperPath} (present)` : "missing"}`,
+  );
+  console.log(
+    `approval_runner: ${env.approvalWhitelistRunnerExists ? `${env.rel.approvalWhitelistRunnerPath} (present)` : "missing"}`,
+  );
+  console.log(
+    `approval_watchdog: ${env.approvalWhitelistWatchdogExists ? `${env.rel.approvalWhitelistWatchdogPath} (present)` : "missing"}`,
+  );
+  console.log(`watchdog_supervisor: ${env.watchdogSuperviseReady ? "configured" : "incomplete"}`);
+  console.log(
+    `claude_hooks_example: ${env.claudeSettingsExampleExists ? `${env.rel.claudeSettingsExamplePath} (present)` : "missing"}`,
+  );
+  console.log(
+    `tmux_helpers: scan=${env.tmuxScanHelperExists ? env.rel.tmuxScanHelperPath : "missing"}, rescue=${
+      env.tmuxRescueHelperExists ? env.rel.tmuxRescueHelperPath : "missing"
+    }`,
+  );
+  console.log(`autonomy_ready: ${env.autonomyReady}`);
 
   if (env.configStatus === "invalid") {
     console.log(`Next: 修复 ${env.rel.configPath} 的 JSON，然后重新运行 aiws opencode status .`);
     return;
   }
   if (!env.configExists && env.exampleExists) {
-    console.log(`Next: 如需启用 oMo 优先模式，可复制 ${env.rel.examplePath} -> ${env.rel.configPath} 后按项目调整 agents。`);
+    console.log(`Next: 如需启用 oMo 优先模式，可复制 ${env.rel.examplePath} -> ${env.rel.configPath} 后按项目调整 agents；随后运行 \`aiws opencode auto .\` 或 \`/ws-auto\`.`);
     return;
   }
   if (env.mode === "oMo-enabled" && !env.recommendedAgentsReady) {
     console.log("Next: 补齐 planner-sisyphus / librarian / explore / oracle，或接受 fallback 到 standard-opencode。");
     return;
   }
+  if (env.mode === "oMo-enabled" && !env.autonomyReady) {
+    console.log(
+      "Next: 如需 autonomous 模式，补齐 planner-sisyphus.prompt_append / backgroundTasks / experimental.auto_resume / approval whitelist，并确认 .claude/settings.json.example / approval helper / approval runner / approval watchdog / tmux helpers 存在。",
+    );
+    return;
+  }
   if (env.mode === "oMo-enabled") {
-    console.log("Next: 运行 /using-aiws 或 /ws-preflight，确认技能路由输出 OpenCode mode: oMo-enabled。");
+    if (env.watchdogSuperviseReady) {
+      console.log("Next: 如需一键做 bootstrap + watchdog ensure，运行 `aiws opencode auto .` 或 `/ws-auto`；若只想单独拉起 watchdog，再用 `aiws opencode supervise .`。");
+      return;
+    }
+    console.log("Next: 运行 /ws-autonomy 或 /using-aiws，确认当前仓库的 completion/retry/rescue 合同。");
     return;
   }
   console.log("Next: 当前按 standard-opencode 运行；如需多 agent 优先委托，可启用 oh-my-opencode 项目配置。");

package/src/commands/opencode-supervise.js

@@ -0,0 +1,200 @@
+import { createHash } from "node:crypto";
+import path from "node:path";
+import { spawnSync } from "node:child_process";
+import { UserError } from "../errors.js";
+import { resolveWorkspaceRoot } from "../workspace.js";
+import { detectOpenCodeEnvironment } from "../opencode-env.js";
+
+function shellQuote(value) {
+  return `'${String(value).replaceAll("'", `'\\''`)}'`;
+}
+
+function sanitizeName(value) {
+  return String(value || "")
+    .replaceAll(/[^A-Za-z0-9._-]+/g, "-")
+    .replaceAll(/^-+|-+$/g, "") || "workspace";
+}
+
+function defaultSessionName(workspaceRoot) {
+  const baseName = sanitizeName(path.basename(workspaceRoot));
+  const hash = createHash("sha1").update(workspaceRoot).digest("hex").slice(0, 6);
+  return `${baseName}-${hash}`;
+}
+
+function runTmux(args, options = {}) {
+  const result = spawnSync("tmux", args, {
+    encoding: "utf8",
+    env: process.env,
+  });
+  if (options.allowFailure === true) {
+    return result;
+  }
+  if (result.error) {
+    throw new UserError(`Failed to run tmux ${args[0] ?? ""}`.trim(), {
+      details: result.error instanceof Error ? result.error.message : String(result.error),
+    });
+  }
+  if (result.status !== 0) {
+    const stderr = (result.stderr || "").trim();
+    throw new UserError(`tmux ${args[0] ?? ""} failed`, { details: stderr || `exit=${result.status}` });
+  }
+  return result;
+}
+
+export function tmuxInstalled() {
+  const result = spawnSync("tmux", ["-V"], {
+    encoding: "utf8",
+    env: process.env,
+  });
+  return !result.error && result.status === 0;
+}
+
+function parsePositiveInt(value, optionName) {
+  const parsed = Number.parseInt(String(value), 10);
+  if (!Number.isFinite(parsed) || parsed <= 0) {
+    throw new UserError(`Invalid ${optionName}: ${value}`, { details: `${optionName} must be a positive integer.` });
+  }
+  return parsed;
+}
+
+function buildWatchdogCommand(env, workspaceRoot, options) {
+  const autonomyDir = path.join(workspaceRoot, ".agentdocs", "tmp", "opencode-autonomy");
+  const args = [shellQuote(env.approvalWhitelistWatchdogPath), shellQuote(workspaceRoot)];
+  if (options.once === true) {
+    args.push("--once");
+  }
+  if (options.pollMs !== null) {
+    args.push("--poll-ms", String(options.pollMs));
+  }
+  return `mkdir -p ${shellQuote(autonomyDir)} && export AIWS_OPENCODE_AUTONOMY_DIR=${shellQuote(autonomyDir)} && exec bash ${args.join(" ")}`;
+}
+
+function currentTmuxSessionName() {
+  if (!process.env.TMUX) {
+    return "";
+  }
+  const result = runTmux(["display-message", "-p", "#S"]);
+  return (result.stdout || "").trim();
+}
+
+function sessionExists(sessionName) {
+  const result = runTmux(["has-session", "-t", sessionName], { allowFailure: true });
+  return result.status === 0;
+}
+
+function windowExists(sessionName, windowName) {
+  const result = runTmux(["list-windows", "-t", sessionName, "-F", "#W"], { allowFailure: true });
+  if (result.status !== 0) {
+    return false;
+  }
+  return String(result.stdout || "")
+    .split(/\r?\n/)
+    .map((line) => line.trim())
+    .filter(Boolean)
+    .includes(windowName);
+}
+
+/**
+ * @param {{
+ *   workspaceRoot: string,
+ *   env: Awaited<ReturnType<typeof detectOpenCodeEnvironment>>,
+ *   sessionName?: string,
+ *   windowName?: string,
+ *   once?: boolean,
+ *   pollMs?: string | null,
+ * }} options
+ */
+export function ensureOpenCodeWatchdog(options) {
+  const workspaceRoot = options.workspaceRoot;
+  const env = options.env;
+  if (!tmuxInstalled()) {
+    throw new UserError("tmux is required for watchdog supervision.", {
+      details: "Install tmux first, or run the watchdog helper manually.",
+    });
+  }
+  if (env.configStatus !== "loaded") {
+    throw new UserError("oMo config is not ready for supervision.", {
+      details: `Expected ${env.rel.configPath} to exist and be valid JSON before starting watchdog supervision.`,
+    });
+  }
+  if (!env.approvalWhitelist.configured) {
+    throw new UserError("approval whitelist policy is not ready.", {
+      details: "Enable aiws.autonomy.approval_whitelist with assist-only + manual-only before starting watchdog supervision.",
+    });
+  }
+  if (!env.approvalWhitelistHelperExists || !env.approvalWhitelistRunnerExists || !env.approvalWhitelistWatchdogExists) {
+    throw new UserError("watchdog helper chain is incomplete.", {
+      details: "Expected approval-whitelist-check.sh, approval-whitelist-run.sh, and approval-whitelist-watchdog.sh to exist under .opencode/helpers/.",
+    });
+  }
+
+  const pollMs = options.pollMs ? parsePositiveInt(options.pollMs, "--poll-ms") : null;
+  const currentSession = currentTmuxSessionName();
+  const sessionName = options.sessionName || currentSession || defaultSessionName(workspaceRoot);
+  const windowName = options.windowName || "watchdog";
+  const command = buildWatchdogCommand(env, workspaceRoot, {
+    once: options.once === true,
+    pollMs,
+  });
+  const existed = sessionExists(sessionName);
+
+  if (existed && windowExists(sessionName, windowName)) {
+    return {
+      sessionName,
+      windowName,
+      helperRelPath: env.rel.approvalWhitelistWatchdogPath,
+      state: "already-running",
+      currentSession: Boolean(currentSession && sessionName === currentSession),
+      once: options.once === true,
+      pollMs,
+    };
+  }
+
+  if (existed) {
+    runTmux(["new-window", "-d", "-t", sessionName, "-n", windowName, "-c", workspaceRoot, command]);
+  } else {
+    runTmux(["new-session", "-d", "-s", sessionName, "-n", windowName, "-c", workspaceRoot, command]);
+  }
+
+  return {
+    sessionName,
+    windowName,
+    helperRelPath: env.rel.approvalWhitelistWatchdogPath,
+    state: existed ? "created" : "started-with-new-session",
+    currentSession: Boolean(currentSession && sessionName === currentSession),
+    once: options.once === true,
+    pollMs,
+  };
+}
+
+/**
+ * @param {{ targetPath: string, sessionName?: string, windowName?: string, once?: boolean, pollMs?: string }} options
+ */
+export async function opencodeSuperviseCommand(options) {
+  const workspaceRoot = await resolveWorkspaceRoot(options.targetPath, { create: false });
+  const env = await detectOpenCodeEnvironment(workspaceRoot);
+  const result = ensureOpenCodeWatchdog({
+    workspaceRoot,
+    env,
+    sessionName: options.sessionName,
+    windowName: options.windowName,
+    once: options.once,
+    pollMs: options.pollMs ?? null,
+  });
+
+  console.log(`✓ aiws opencode supervise: ${workspaceRoot}`);
+  console.log(`tmux session: ${result.sessionName}${result.currentSession ? " (current)" : ""}`);
+  if (result.state === "already-running") {
+    console.log(`watchdog window: ${result.windowName} (already running)`);
+  } else if (result.state === "created") {
+    console.log(`watchdog window: ${result.windowName} (created)`);
+  } else {
+    console.log(`watchdog window: ${result.windowName} (started with new session)`);
+  }
+  console.log(`watchdog helper: ${result.helperRelPath}`);
+  if (result.once) {
+    console.log("mode: once");
+  } else {
+    console.log(`mode: loop${result.pollMs !== null ? ` (poll_ms=${result.pollMs})` : ""}`);
+  }
+}

package/src/commands/update.js

@@ -10,7 +10,7 @@ import { findManagedBlock } from "../managed-blocks.js";
 import { BackupSession } from "../backup.js";
 import { normalizeRel, joinRel } from "../path-utils.js";
 import { copyTemplateFileToWorkspace, applyManagedBlocksFromTemplate } from "../template.js";
-import { writeWorkspaceManifest } from "../manifest.js";
+import { detectLegacyWorkspaceTemplateId, writeWorkspaceManifest } from "../manifest.js";
 
 /**
  * @param {{ targetPath: string }} options
@@ -20,11 +20,17 @@ export async function updateCommand(options) {
   const aiws = await loadAiwsPackage();
 
   const manifestPath = path.join(workspaceRoot, ".aiws", "manifest.json");
-  if (!(await pathExists(manifestPath))) {
+  const hasManifest = await pathExists(manifestPath);
+  const legacyTemplateId = !hasManifest ? await detectLegacyWorkspaceTemplateId(workspaceRoot) : null;
+  const legacyMigration = !hasManifest && Boolean(legacyTemplateId);
+  if (!hasManifest && !legacyTemplateId) {
     throw new UserError("Missing .aiws/manifest.json. Run `aiws init` first.");
   }
-  const stored = JSON.parse(await readText(manifestPath));
-  const templateId = String(stored.template_id || "workspace");
+
+  const stored = hasManifest
+    ? JSON.parse(await readText(manifestPath))
+    : { template_id: legacyTemplateId, installed_at: "", tools: [], managed: [] };
+  const templateId = String(stored.template_id || legacyTemplateId || "workspace");
   const tpl = await loadTemplate(templateId);
   const storedManagedByPath = new Map(
     (Array.isArray(stored.managed) ? stored.managed : [])
@@ -56,6 +62,9 @@ export async function updateCommand(options) {
     const ids = Array.isArray(blockIdsRaw) ? blockIdsRaw.map(String) : [];
     for (const id of ids) {
       if (!findManagedBlock(text, id)) {
+        if (legacyMigration) {
+          continue;
+        }
         throw new UserError("Managed block markers are missing or broken; refusing to update.", {
           details: `File: ${fileRel}\nBlock: ${id}\nHint: re-run \`aiws init\` or repair markers manually.`,
         });
@@ -109,7 +118,7 @@ export async function updateCommand(options) {
       workspaceRoot,
       fileRel,
       blockIds: ids,
-      insertIfMissing: false,
+      insertIfMissing: legacyMigration,
     });
   }
 
@@ -129,5 +138,8 @@ export async function updateCommand(options) {
     templateManifest: tpl.manifest,
   });
 
+  if (legacyMigration) {
+    console.log(`  migrated legacy AIWS workspace: generated .aiws/manifest.json for template=${legacyTemplateId}`);
+  }
   console.log(`✓ aiws update: ${workspaceRoot}`);
 }

package/src/commands/validate.js

@@ -3,7 +3,7 @@ import { loadTemplate } from "../spec.js";
 import { resolveWorkspaceRoot } from "../workspace.js";
 import { ensureDir, pathExists, readText, writeText } from "../fs.js";
 import { UserError } from "../errors.js";
-import { validateDrift } from "../manifest.js";
+import { detectLegacyWorkspaceTemplateId, validateDrift } from "../manifest.js";
 import { runCommand } from "../exec.js";
 import { expandManifestEntries } from "../template.js";
 import { loadAiwsPackage } from "../aiws-package.js";
@@ -142,6 +142,12 @@ export async function validateCommand(options) {
 
     const manifestPath = path.join(workspaceRoot, ".aiws", "manifest.json");
     if (!(await pathExists(manifestPath))) {
+      const legacyTemplateId = await detectLegacyWorkspaceTemplateId(workspaceRoot);
+      if (legacyTemplateId) {
+        throw new UserError("Missing .aiws/manifest.json in a legacy AIWS workspace.", {
+          details: "This workspace looks like an older AIWS install. Run `aiws update .` once to generate the manifest, then rerun `aiws validate`.",
+        });
+      }
       throw new UserError("Missing .aiws/manifest.json. Run `aiws init` first.");
     }
     const stored = JSON.parse(await readText(manifestPath));

package/src/commands/ws-commit.js

@@ -0,0 +1,44 @@
+import { execSync } from "node:child_process";
+import { existsSync } from "node:fs";
+import { UserError } from "../errors.js";
+
+/**
+ * aiws commit — validate + commit
+ * @param {{ cwd?: string, message?: string }} opts
+ */
+export async function wsCommitCommand({ cwd = ".", message } = {}) {
+  checkClean(cwd);
+
+  // Check review artifacts
+  const reviewsExist = existsSync(`${cwd}/changes/*/review/spec-review.md`) ||
+    existsSync(`${cwd}/changes/*/review/quality-review.md`);
+  if (!reviewsExist) {
+    console.log("warn: no spec-review or quality-review found");
+  }
+
+  // Run validate
+  try {
+    execSync("npx -y @aipper/aiws validate . 2>/dev/null || aiws validate . 2>/dev/null || true", { cwd, stdio: "inherit" });
+  } catch { /* validate is advisory, not blocking */ }
+
+  // Get staged changes
+  const staged = execSync("git diff --cached --name-only", { cwd, encoding: "utf8" }).trim();
+  if (!staged) {
+    console.log("info: nothing staged. Use git add first.");
+  }
+
+  // Commit
+  if (!message) {
+    throw new UserError("commit requires --message (use -m or --message)", { exitCode: 2 });
+  }
+
+  execSync(`git commit -m "${message.replace(/"/g, '\\"')}"`, { cwd, stdio: "inherit" });
+  console.log("ok: commit created");
+}
+
+function checkClean(cwd) {
+  const out = execSync("git status --porcelain", { cwd, encoding: "utf8" }).trim();
+  if (!out) {
+    throw new UserError("Nothing to commit. Working tree clean.", { exitCode: 2 });
+  }
+}

package/src/commands/ws-deliver.js

@@ -0,0 +1,67 @@
+import { execSync } from "node:child_process";
+import { existsSync, readFileSync } from "node:fs";
+import { UserError } from "../errors.js";
+
+/**
+ * aiws deliver — submodule + superproject commit, then finish
+ * @param {{ cwd?: string, message?: string, changeId?: string }} opts
+ */
+export async function wsDeliverCommand({ cwd = ".", message, changeId } = {}) {
+  if (!changeId) {
+    changeId = detectChangeBranch(cwd);
+  }
+  if (!changeId) {
+    throw new UserError("Could not detect change ID.", { exitCode: 2 });
+  }
+
+  if (!message) {
+    throw new UserError("deliver requires --message for the superproject commit", { exitCode: 2 });
+  }
+
+  console.log("info: starting delivery...");
+
+  // Commit submodules first
+  if (existsSync(`${cwd}/.gitmodules`)) {
+    const out = execSync("git config --file .gitmodules --get-regexp '^submodule\\..*\\.path$'", {
+      cwd, encoding: "utf8",
+    }).trim();
+
+    for (const line of out.split("\n")) {
+      const parts = line.trim().split(/\s+/);
+      if (parts.length < 2) continue;
+      const subPath = parts[1];
+
+      const status = execSync(`git -C "${subPath}" status --porcelain`, { cwd, encoding: "utf8" }).trim();
+      if (status) {
+        console.log(`info: submodule ${subPath} has changes. Committing...`);
+        execSync(`git -C "${subPath}" add -A`, { cwd, stdio: "inherit" });
+        execSync(`git -C "${subPath}" commit -m "${message}"`, { cwd, stdio: "inherit" });
+      } else {
+        console.log(`info: submodule ${subPath} has no changes, skipping`);
+      }
+    }
+  }
+
+  // Commit superproject
+  const superStatus = execSync("git status --porcelain", { cwd, encoding: "utf8" }).trim();
+  if (superStatus) {
+    console.log("info: committing superproject...");
+    execSync("git add -A", { cwd, stdio: "inherit" });
+    execSync(`git commit -m "${message}"`, { cwd, stdio: "inherit" });
+  } else {
+    console.log("info: superproject has no changes");
+  }
+
+  // Finish
+  await import("./ws-finish.js").then(m =>
+    m.wsFinishCommand({ cwd, changeId, push: true })
+  );
+
+  console.log("ok: deliver complete");
+}
+
+function detectChangeBranch(cwd) {
+  const branch = execSync("git branch --show-current", { cwd, encoding: "utf8" }).trim();
+  const match = branch.match(/^(?:change|changes|ws|ws-change)\/(.+)$/);
+  return match ? match[1] : null;
+}