@locusai/cli 0.22.9 → 0.22.11

package/bin/locus.js

@@ -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)
 `);
@@ -4893,39 +4896,49 @@ class ClaudeRunner {
         stdio: ["pipe", "pipe", "pipe"],
         env
       });
+      let flushLineBuffer = null;
       if (options.verbose) {
         let lineBuffer = "";
         const seenToolIds = new Set;
+        const processLine = (line) => {
+          if (!line.trim())
+            return;
+          try {
+            const event = JSON.parse(line);
+            if (event.type === "assistant" && event.message?.content) {
+              for (const item of event.message.content) {
+                if (item.type === "tool_use" && item.id && !seenToolIds.has(item.id)) {
+                  seenToolIds.add(item.id);
+                  options.onToolActivity?.(formatToolCall(item.name ?? "", item.input ?? {}));
+                }
+              }
+            } else if (event.type === "result") {
+              const text = event.result ?? "";
+              output = text;
+              options.onOutput?.(text);
+            }
+          } catch {
+            const newLine = `${line}
+`;
+            output += newLine;
+            options.onOutput?.(newLine);
+          }
+        };
         this.process.stdout?.on("data", (chunk) => {
           lineBuffer += chunk.toString();
           const lines = lineBuffer.split(`
 `);
           lineBuffer = lines.pop() ?? "";
           for (const line of lines) {
-            if (!line.trim())
-              continue;
-            try {
-              const event = JSON.parse(line);
-              if (event.type === "assistant" && event.message?.content) {
-                for (const item of event.message.content) {
-                  if (item.type === "tool_use" && item.id && !seenToolIds.has(item.id)) {
-                    seenToolIds.add(item.id);
-                    options.onToolActivity?.(formatToolCall(item.name ?? "", item.input ?? {}));
-                  }
-                }
-              } else if (event.type === "result") {
-                const text = event.result ?? "";
-                output = text;
-                options.onOutput?.(text);
-              }
-            } catch {
-              const newLine = `${line}
-`;
-              output += newLine;
-              options.onOutput?.(newLine);
-            }
+            processLine(line);
           }
         });
+        flushLineBuffer = () => {
+          if (lineBuffer.trim()) {
+            processLine(lineBuffer);
+            lineBuffer = "";
+          }
+        };
       } else {
         this.process.stdout?.on("data", (chunk) => {
           const text = chunk.toString();
@@ -4940,6 +4953,7 @@ class ClaudeRunner {
       });
       this.process.on("close", (code) => {
         this.process = null;
+        flushLineBuffer?.();
         if (this.aborted) {
           resolve2({
             success: false,
@@ -5314,39 +5328,49 @@ class SandboxedClaudeRunner {
           stdio: ["ignore", "pipe", "pipe"],
           env: process.env
         });
+        let flushLineBuffer = null;
         if (options.verbose) {
           let lineBuffer = "";
           const seenToolIds = new Set;
+          const processLine = (line) => {
+            if (!line.trim())
+              return;
+            try {
+              const event = JSON.parse(line);
+              if (event.type === "assistant" && event.message?.content) {
+                for (const item of event.message.content) {
+                  if (item.type === "tool_use" && item.id && !seenToolIds.has(item.id)) {
+                    seenToolIds.add(item.id);
+                    options.onToolActivity?.(formatToolCall2(item.name ?? "", item.input ?? {}));
+                  }
+                }
+              } else if (event.type === "result") {
+                const text = event.result ?? "";
+                output = text;
+                options.onOutput?.(text);
+              }
+            } catch {
+              const newLine = `${line}
+`;
+              output += newLine;
+              options.onOutput?.(newLine);
+            }
+          };
           this.process.stdout?.on("data", (chunk) => {
             lineBuffer += chunk.toString();
             const lines = lineBuffer.split(`
 `);
             lineBuffer = lines.pop() ?? "";
             for (const line of lines) {
-              if (!line.trim())
-                continue;
-              try {
-                const event = JSON.parse(line);
-                if (event.type === "assistant" && event.message?.content) {
-                  for (const item of event.message.content) {
-                    if (item.type === "tool_use" && item.id && !seenToolIds.has(item.id)) {
-                      seenToolIds.add(item.id);
-                      options.onToolActivity?.(formatToolCall2(item.name ?? "", item.input ?? {}));
-                    }
-                  }
-                } else if (event.type === "result") {
-                  const text = event.result ?? "";
-                  output = text;
-                  options.onOutput?.(text);
-                }
-              } catch {
-                const newLine = `${line}
-`;
-                output += newLine;
-                options.onOutput?.(newLine);
-              }
+              processLine(line);
             }
           });
+          flushLineBuffer = () => {
+            if (lineBuffer.trim()) {
+              processLine(lineBuffer);
+              lineBuffer = "";
+            }
+          };
         } else {
           this.process.stdout?.on("data", (chunk) => {
             const text = chunk.toString();
@@ -5361,6 +5385,7 @@ class SandboxedClaudeRunner {
         });
         this.process.on("close", (code) => {
           this.process = null;
+          flushLineBuffer?.();
           if (this.aborted) {
             resolve2({
               success: false,
@@ -10177,22 +10202,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 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) {
-  const path = getRunStatePath(projectRoot);
+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 +10235,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);
   }
@@ -10503,7 +10538,12 @@ function resolveExecutionContext(config, modelOverride) {
   const model = modelOverride ?? config.ai.model;
   const provider = inferProviderFromModel(model) ?? config.ai.provider;
   const sandboxName = getModelSandboxName(config.sandbox, model, provider);
-  return { provider, model, sandboxName, containerWorkdir: config.sandbox.containerWorkdir };
+  return {
+    provider,
+    model,
+    sandboxName,
+    containerWorkdir: config.sandbox.containerWorkdir
+  };
 }
 function printRunHelp() {
   process.stderr.write(`
@@ -10544,9 +10584,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 +10621,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 +10635,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 +10646,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 +10827,7 @@ ${bold2("Summary:")}
     }
   }
   if (stats.failed === 0) {
-    clearRunState(projectRoot);
+    clearRunState(projectRoot, sprintName);
   }
 }
 async function handleSingleIssue(projectRoot, config, issueNumber, flags, sandboxed) {
@@ -10966,14 +11008,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 +11115,7 @@ ${bold2("Resume complete:")} ${green(`✓ ${finalStats.done}`)} ${finalStats.fai
     }
   }
   if (finalStats.failed === 0) {
-    clearRunState(projectRoot);
+    clearRunState(projectRoot, state.sprint);
   }
 }
 function sortByOrder2(issues) {
@@ -13018,6 +13065,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 +13262,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 +13498,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 +13790,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 +14003,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 +14018,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 +14027,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 +14039,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 +14047,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 +14056,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 +14099,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 +14266,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 +14314,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 +14555,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 +14600,6 @@ ${dim2(error.stack)}
   }
   process.exit(1);
 });
+export {
+  normalizeArgs
+};

package/package.json

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