@locusai/cli 0.22.8 → 0.22.10

package/bin/locus.js

@@ -1047,7 +1047,7 @@ function detectContainerWorkdir(sandboxName, hostProjectRoot) {
   try {
     const raw = execSync2(`docker sandbox exec ${sandboxName} cat /proc/mounts`, { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"], timeout: 5000 }).trim();
     if (raw) {
-      const systemPrefixes = ["/proc", "/sys", "/dev"];
+      const systemPrefixes = ["/proc", "/sys", "/dev", "/run"];
       const candidates = raw.split(`
 `).map((line) => {
         const fields = line.split(" ");
@@ -1055,7 +1055,7 @@ function detectContainerWorkdir(sandboxName, hostProjectRoot) {
       }).filter((mp) => !!mp && mp !== "/" && !systemPrefixes.some((p) => mp === p || mp.startsWith(`${p}/`)));
       for (const candidate of candidates) {
         try {
-          execSync2(`docker sandbox exec ${sandboxName} sh -c "test -d ${JSON.stringify(`${candidate}/`)} || test -f ${JSON.stringify(`${candidate}/package.json`)}"`, { stdio: ["pipe", "pipe", "pipe"], timeout: 3000 });
+          execSync2(`docker sandbox exec ${sandboxName} sh -c "test -d ${JSON.stringify(`${candidate}/.git`)} || test -f ${JSON.stringify(`${candidate}/package.json`)}"`, { stdio: ["pipe", "pipe", "pipe"], timeout: 3000 });
           log.debug("Detected container workdir from mount table", {
             hostProjectRoot,
             containerWorkdir: candidate
@@ -1952,7 +1952,8 @@ ${bold2("Initializing Locus...")}
     join6(locusDir, "discussions"),
     join6(locusDir, "artifacts"),
     join6(locusDir, "plans"),
-    join6(locusDir, "logs")
+    join6(locusDir, "logs"),
+    join6(locusDir, "run-state")
   ];
   for (const dir of dirs) {
     if (!existsSync6(dir)) {
@@ -1987,6 +1988,8 @@ ${bold2("Initializing Locus...")}
         config.logging = { ...config.logging, ...existing.logging };
       if (existing.sandbox)
         config.sandbox = { ...config.sandbox, ...existing.sandbox };
+      if (existing.packages)
+        config.packages = existing.packages;
     } catch {}
     process.stderr.write(`${green("✓")} Updated config.json (preserved existing settings)
 `);
@@ -10177,22 +10180,32 @@ import {
   writeFileSync as writeFileSync9
 } from "node:fs";
 import { dirname as dirname6, join as join20 } from "node:path";
-function getRunStatePath(projectRoot) {
-  return join20(projectRoot, ".locus", "run-state.json");
+function getRunStateDir(projectRoot) {
+  return join20(projectRoot, ".locus", "run-state");
 }
-function loadRunState(projectRoot) {
-  const path = getRunStatePath(projectRoot);
+function sprintSlug(name) {
+  return name.trim().toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
+}
+function getRunStatePath(projectRoot, sprintName) {
+  const dir = getRunStateDir(projectRoot);
+  if (sprintName) {
+    return join20(dir, `${sprintSlug(sprintName)}.json`);
+  }
+  return join20(dir, "_parallel.json");
+}
+function loadRunState(projectRoot, sprintName) {
+  const path = getRunStatePath(projectRoot, sprintName);
   if (!existsSync20(path))
     return null;
   try {
     return JSON.parse(readFileSync12(path, "utf-8"));
   } catch {
-    getLogger().warn("Corrupted run-state.json, ignoring");
+    getLogger().warn("Corrupted run state file, ignoring");
     return null;
   }
 }
 function saveRunState(projectRoot, state) {
-  const path = getRunStatePath(projectRoot);
+  const path = getRunStatePath(projectRoot, state.sprint);
   const dir = dirname6(path);
   if (!existsSync20(dir)) {
     mkdirSync14(dir, { recursive: true });
@@ -10200,8 +10213,8 @@ function saveRunState(projectRoot, state) {
   writeFileSync9(path, `${JSON.stringify(state, null, 2)}
 `, "utf-8");
 }
-function clearRunState(projectRoot) {
-  const path = getRunStatePath(projectRoot);
+function clearRunState(projectRoot, sprintName) {
+  const path = getRunStatePath(projectRoot, sprintName);
   if (existsSync20(path)) {
     unlinkSync5(path);
   }
@@ -10544,9 +10557,10 @@ async function runCommand(projectRoot, args, flags = {}) {
   }
   const config = loadConfig(projectRoot);
   const _log = getLogger();
+  const runRef = { sprintName: undefined };
   const cleanupShutdown = registerShutdownHandlers({
     projectRoot,
-    getRunState: () => loadRunState(projectRoot)
+    getRunState: () => loadRunState(projectRoot, runRef.sprintName)
   });
   try {
     const sandboxMode = resolveSandboxMode(config.sandbox, flags);
@@ -10580,11 +10594,11 @@ async function runCommand(projectRoot, args, flags = {}) {
       }
     }
     if (flags.resume) {
-      return handleResume(projectRoot, config, sandboxed);
+      return handleResume(projectRoot, config, sandboxed, runRef);
     }
     const issueNumbers = args.filter((a) => /^\d+$/.test(a)).map(Number);
     if (issueNumbers.length === 0) {
-      return handleSprintRun(projectRoot, config, flags, sandboxed);
+      return handleSprintRun(projectRoot, config, flags, sandboxed, runRef);
     }
     if (issueNumbers.length === 1) {
       return handleSingleIssue(projectRoot, config, issueNumbers[0], flags, sandboxed);
@@ -10594,7 +10608,7 @@ async function runCommand(projectRoot, args, flags = {}) {
     cleanupShutdown();
   }
 }
-async function handleSprintRun(projectRoot, config, flags, sandboxed) {
+async function handleSprintRun(projectRoot, config, flags, sandboxed, runRef) {
   const log = getLogger();
   const execution = resolveExecutionContext(config, flags.model);
   if (!config.sprint.active) {
@@ -10605,15 +10619,16 @@ async function handleSprintRun(projectRoot, config, flags, sandboxed) {
     return;
   }
   const sprintName = config.sprint.active;
+  runRef.sprintName = sprintName;
   process.stderr.write(`
 ${bold2("Sprint:")} ${cyan2(sprintName)}
 `);
-  const existingState = loadRunState(projectRoot);
-  if (existingState && existingState.type === "sprint") {
+  const existingState = loadRunState(projectRoot, sprintName);
+  if (existingState) {
     const stats2 = getRunStats(existingState);
     if (stats2.inProgress > 0 || stats2.pending > 0) {
       process.stderr.write(`
-${yellow2("⚠")} A sprint run is already in progress.
+${yellow2("⚠")} A run for this sprint is already in progress.
 `);
       process.stderr.write(`  Use ${bold2("locus run --resume")} to continue.
 `);
@@ -10785,7 +10800,7 @@ ${bold2("Summary:")}
     }
   }
   if (stats.failed === 0) {
-    clearRunState(projectRoot);
+    clearRunState(projectRoot, sprintName);
   }
 }
 async function handleSingleIssue(projectRoot, config, issueNumber, flags, sandboxed) {
@@ -10966,14 +10981,19 @@ ${yellow2("⚠")} Failed worktrees preserved for debugging:
     clearRunState(projectRoot);
   }
 }
-async function handleResume(projectRoot, config, sandboxed) {
+async function handleResume(projectRoot, config, sandboxed, runRef) {
   const execution = resolveExecutionContext(config);
-  const state = loadRunState(projectRoot);
+  const sprintName = config.sprint.active ?? undefined;
+  let state = sprintName ? loadRunState(projectRoot, sprintName) : null;
+  if (!state) {
+    state = loadRunState(projectRoot);
+  }
   if (!state) {
     process.stderr.write(`${red2("✗")} No run state found. Nothing to resume.
 `);
     return;
   }
+  runRef.sprintName = state.sprint;
   const stats = getRunStats(state);
   process.stderr.write(`
 ${bold2("Resuming")} ${state.type} run ${dim2(state.runId)}
@@ -11068,7 +11088,7 @@ ${bold2("Resume complete:")} ${green(`✓ ${finalStats.done}`)} ${finalStats.fai
     }
   }
   if (finalStats.failed === 0) {
-    clearRunState(projectRoot);
+    clearRunState(projectRoot, state.sprint);
   }
 }
 function sortByOrder2(issues) {
@@ -13018,6 +13038,196 @@ var init_artifacts = __esm(() => {
   init_terminal();
 });
 
+// src/commands/commit.ts
+var exports_commit = {};
+__export(exports_commit, {
+  commitCommand: () => commitCommand
+});
+import { execSync as execSync20 } from "node:child_process";
+function printCommitHelp() {
+  process.stderr.write(`
+${bold2("locus commit")} — AI-powered commit message generation
+
+${bold2("Usage:")}
+  locus commit                       ${dim2("# Analyze staged changes and commit")}
+  locus commit --dry-run             ${dim2("# Preview message without committing")}
+  locus commit --model <name>        ${dim2("# Override AI model")}
+
+${bold2("Options:")}
+  --dry-run             Show the generated message without committing
+  --model <name>        Override the AI model for message generation
+
+${bold2("How it works:")}
+  1. Reads your staged changes (git diff --cached)
+  2. Reads recent commit history for style matching
+  3. Uses AI to generate a conventional commit message
+  4. Appends Co-Authored-By trailer and commits
+
+${bold2("Examples:")}
+  locus commit                       ${dim2("# Stage changes, then run")}
+  locus commit --dry-run             ${dim2("# Preview before committing")}
+
+`);
+}
+async function commitCommand(projectRoot, args, flags = {}) {
+  if (args[0] === "help") {
+    printCommitHelp();
+    return;
+  }
+  const config = loadConfig(projectRoot);
+  let stagedDiff;
+  try {
+    stagedDiff = execSync20("git diff --cached", {
+      cwd: projectRoot,
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"]
+    }).trim();
+  } catch {
+    process.stderr.write(`${red2("✗")} Failed to read staged changes.
+`);
+    return;
+  }
+  if (!stagedDiff) {
+    process.stderr.write(`${red2("✗")} No staged changes. Stage files first with ${bold2("git add")}.
+`);
+    return;
+  }
+  let stagedStat;
+  try {
+    stagedStat = execSync20("git diff --cached --stat", {
+      cwd: projectRoot,
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"]
+    }).trim();
+  } catch {
+    stagedStat = "";
+  }
+  let recentCommits;
+  try {
+    recentCommits = execSync20("git log --oneline -10", {
+      cwd: projectRoot,
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"]
+    }).trim();
+  } catch {
+    recentCommits = "";
+  }
+  process.stderr.write(`
+${bold2("Analyzing staged changes...")}
+`);
+  process.stderr.write(`${dim2(stagedStat)}
+
+`);
+  const prompt = buildCommitPrompt(stagedDiff, stagedStat, recentCommits);
+  const model = flags.model ?? config.ai.model;
+  const provider = inferProviderFromModel(model) ?? config.ai.provider;
+  const sandboxName = getModelSandboxName(config.sandbox, model, provider);
+  const result = await runAI({
+    prompt,
+    provider,
+    model,
+    cwd: projectRoot,
+    activity: "Generating commit message",
+    silent: true,
+    noInterrupt: true,
+    sandboxed: !!sandboxName,
+    sandboxName,
+    containerWorkdir: config.sandbox.containerWorkdir
+  });
+  if (!result.success) {
+    process.stderr.write(`${red2("✗")} Failed to generate commit message: ${result.error}
+`);
+    return;
+  }
+  const commitMessage = extractCommitMessage(result.output);
+  if (!commitMessage) {
+    process.stderr.write(`${red2("✗")} Could not extract a commit message from AI response.
+`);
+    return;
+  }
+  const fullMessage = `${commitMessage}
+
+Co-Authored-By: LocusAgent <agent@locusai.team>`;
+  process.stderr.write(`${bold2("Generated commit message:")}
+`);
+  process.stderr.write(`${cyan2("─".repeat(50))}
+`);
+  process.stderr.write(`${fullMessage}
+`);
+  process.stderr.write(`${cyan2("─".repeat(50))}
+
+`);
+  if (flags.dryRun) {
+    process.stderr.write(`${yellow2("⚠")} ${bold2("Dry run")} — no commit created.
+
+`);
+    return;
+  }
+  try {
+    execSync20("git commit -F -", {
+      input: fullMessage,
+      cwd: projectRoot,
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    process.stderr.write(`${green("✓")} Committed successfully.
+
+`);
+  } catch (e) {
+    process.stderr.write(`${red2("✗")} Commit failed: ${e.message}
+`);
+  }
+}
+function buildCommitPrompt(diff, stat, recentCommits) {
+  const maxDiffLength = 15000;
+  const truncatedDiff = diff.length > maxDiffLength ? `${diff.slice(0, maxDiffLength)}
+
+... [diff truncated — ${diff.length - maxDiffLength} chars omitted]` : diff;
+  let prompt = `You are a commit message generator. Analyze the following staged git changes and generate a single, concise conventional commit message.
+
+Rules:
+- Use conventional commit format: type(scope): description
+- Types: feat, fix, chore, refactor, docs, test, style, perf, ci, build
+- Keep the first line under 72 characters
+- Add a body paragraph (separated by blank line) ONLY if the changes are complex enough to warrant explanation
+- Do NOT include any markdown formatting, code blocks, or extra commentary
+- Output ONLY the commit message text — nothing else
+
+`;
+  if (recentCommits) {
+    prompt += `Recent commits (for style reference):
+${recentCommits}
+
+`;
+  }
+  prompt += `File summary:
+${stat}
+
+Diff:
+${truncatedDiff}`;
+  return prompt;
+}
+function extractCommitMessage(output) {
+  const trimmed = output.trim();
+  if (!trimmed)
+    return null;
+  let cleaned = trimmed;
+  if (cleaned.startsWith("```")) {
+    cleaned = cleaned.replace(/^```[^\n]*\n?/, "").replace(/\n?```$/, "");
+  }
+  if (cleaned.startsWith('"') && cleaned.endsWith('"') || cleaned.startsWith("'") && cleaned.endsWith("'")) {
+    cleaned = cleaned.slice(1, -1);
+  }
+  return cleaned.trim() || null;
+}
+var init_commit = __esm(() => {
+  init_run_ai();
+  init_ai_models();
+  init_config();
+  init_sandbox();
+  init_terminal();
+});
+
 // src/commands/sandbox.ts
 var exports_sandbox2 = {};
 __export(exports_sandbox2, {
@@ -13025,7 +13235,7 @@ __export(exports_sandbox2, {
   parseSandboxLogsArgs: () => parseSandboxLogsArgs,
   parseSandboxInstallArgs: () => parseSandboxInstallArgs
 });
-import { execSync as execSync20, spawn as spawn7 } from "node:child_process";
+import { execSync as execSync21, spawn as spawn7 } from "node:child_process";
 import { createHash } from "node:crypto";
 import { existsSync as existsSync26, readFileSync as readFileSync17 } from "node:fs";
 import { basename as basename4, join as join26 } from "node:path";
@@ -13261,7 +13471,7 @@ function handleRemove(projectRoot) {
     process.stderr.write(`Removing sandbox ${bold2(sandboxName)}...
 `);
     try {
-      execSync20(`docker sandbox rm ${sandboxName}`, {
+      execSync21(`docker sandbox rm ${sandboxName}`, {
         encoding: "utf-8",
         stdio: ["pipe", "pipe", "pipe"],
         timeout: 15000
@@ -13553,7 +13763,7 @@ function getInstallCommand(pm) {
 function verifyBinEntries(sandboxName, workdir) {
   try {
     const binDir = `${workdir}/node_modules/.bin/`;
-    const result = execSync20(`docker sandbox exec --privileged ${sandboxName} sh -c ${JSON.stringify(`ls ${JSON.stringify(binDir)} 2>/dev/null | head -20`)}`, { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"], timeout: 5000 }).trim();
+    const result = execSync21(`docker sandbox exec --privileged ${sandboxName} sh -c ${JSON.stringify(`ls ${JSON.stringify(binDir)} 2>/dev/null | head -20`)}`, { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"], timeout: 5000 }).trim();
     if (!result) {
       process.stderr.write(`${yellow2("⚠")} node_modules/.bin is empty — binaries like biome may not be available.
 `);
@@ -13766,7 +13976,7 @@ function runInteractiveCommand(command, args) {
 }
 async function createProviderSandbox(provider, sandboxName, projectRoot) {
   try {
-    execSync20(`docker sandbox create --name ${sandboxName} claude ${projectRoot}`, {
+    execSync21(`docker sandbox create --name ${sandboxName} claude ${projectRoot}`, {
       stdio: ["pipe", "pipe", "pipe"],
       timeout: 120000
     });
@@ -13781,7 +13991,7 @@ async function createProviderSandbox(provider, sandboxName, projectRoot) {
 }
 async function ensurePackageManagerInSandbox(sandboxName, pm) {
   try {
-    execSync20(`docker sandbox exec --privileged ${sandboxName} which ${pm}`, {
+    execSync21(`docker sandbox exec --privileged ${sandboxName} which ${pm}`, {
       stdio: ["pipe", "pipe", "pipe"],
       timeout: 5000
     });
@@ -13790,7 +14000,7 @@ async function ensurePackageManagerInSandbox(sandboxName, pm) {
     process.stderr.write(`Installing ${bold2(pm)} in sandbox...
 `);
     try {
-      execSync20(`docker sandbox exec --privileged ${sandboxName} npm install -g ${npmPkg}`, {
+      execSync21(`docker sandbox exec --privileged ${sandboxName} npm install -g ${npmPkg}`, {
         stdio: "inherit",
         timeout: 120000
       });
@@ -13802,7 +14012,7 @@ async function ensurePackageManagerInSandbox(sandboxName, pm) {
 }
 async function ensureCodexInSandbox(sandboxName) {
   try {
-    execSync20(`docker sandbox exec --privileged ${sandboxName} which codex`, {
+    execSync21(`docker sandbox exec --privileged ${sandboxName} which codex`, {
       stdio: ["pipe", "pipe", "pipe"],
       timeout: 5000
     });
@@ -13810,7 +14020,7 @@ async function ensureCodexInSandbox(sandboxName) {
     process.stderr.write(`Installing codex in sandbox...
 `);
     try {
-      execSync20(`docker sandbox exec --privileged ${sandboxName} npm install -g @openai/codex`, { stdio: "inherit", timeout: 120000 });
+      execSync21(`docker sandbox exec --privileged ${sandboxName} npm install -g @openai/codex`, { stdio: "inherit", timeout: 120000 });
     } catch {
       process.stderr.write(`${red2("✗")} Failed to install codex in sandbox.
 `);
@@ -13819,7 +14029,7 @@ async function ensureCodexInSandbox(sandboxName) {
 }
 function isSandboxAlive(name) {
   try {
-    const output = execSync20("docker sandbox ls", {
+    const output = execSync21("docker sandbox ls", {
       encoding: "utf-8",
       stdio: ["pipe", "pipe", "pipe"],
       timeout: 5000
@@ -13862,8 +14072,17 @@ function getCliVersion() {
   }
 }
 var VERSION = getCliVersion();
+function normalizeArgs(args) {
+  return args.map((arg) => {
+    if (arg.startsWith("--") || !arg.startsWith("-"))
+      return arg;
+    if (arg.length <= 2)
+      return arg;
+    return `-${arg}`;
+  });
+}
 function parseArgs(argv) {
-  const rawArgs = argv.slice(2);
+  const rawArgs = normalizeArgs(argv.slice(2));
   const flags = {
     debug: false,
     help: false,
@@ -14020,6 +14239,7 @@ ${bold2("Commands:")}
   ${cyan2("discuss")}           AI-powered architectural discussions
   ${cyan2("artifacts")}         View and manage AI-generated artifacts
   ${cyan2("status")}            Dashboard view of current state
+  ${cyan2("commit")}            AI-powered commit message generation
   ${cyan2("config")}            View and manage settings
   ${cyan2("logs")}              View, tail, and manage execution logs
   ${cyan2("create")} ${dim2("<name>")}       Scaffold a new community package
@@ -14067,6 +14287,7 @@ function requiresSandboxSync(command, args, flags) {
     case "run":
     case "review":
     case "iterate":
+    case "commit":
       return true;
     case "exec":
       return args[0] !== "sessions" && args[0] !== "help";
@@ -14307,6 +14528,15 @@ async function main() {
       await artifactsCommand2(projectRoot, artifactsArgs);
       break;
     }
+    case "commit": {
+      const { commitCommand: commitCommand2 } = await Promise.resolve().then(() => (init_commit(), exports_commit));
+      const commitArgs = parsed.flags.help ? ["help"] : parsed.args;
+      await commitCommand2(projectRoot, commitArgs, {
+        dryRun: parsed.flags.dryRun,
+        model: parsed.flags.model
+      });
+      break;
+    }
     case "sandbox": {
       const { sandboxCommand: sandboxCommand2 } = await Promise.resolve().then(() => (init_sandbox2(), exports_sandbox2));
       const sandboxArgs = parsed.flags.help ? ["help"] : parsed.args;
@@ -14343,3 +14573,6 @@ ${dim2(error.stack)}
   }
   process.exit(1);
 });
+export {
+  normalizeArgs
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@locusai/cli",
-  "version": "0.22.8",
+  "version": "0.22.10",
   "description": "GitHub-native AI engineering assistant",
   "type": "module",
   "bin": {
@@ -36,7 +36,7 @@
   "license": "MIT",
   "dependencies": {},
   "devDependencies": {
-    "@locusai/sdk": "^0.22.8",
+    "@locusai/sdk": "^0.22.10",
     "@types/bun": "latest",
     "typescript": "^5.8.3"
   },