@bli-cockpit/cli 0.2.3 → 0.2.4

package/README.md

@@ -54,6 +54,7 @@ On a blank Mac, `npm i -g @bli-cockpit/cli && cockpit do-everything` is enough t
 | `cockpit status` | Prints install / sign-in / capture / upload health in one screen. | The "is it working?" command. Run it whenever you're unsure. |
 | `cockpit backfill --all` | Uploads your HISTORICAL Codex + Claude sessions (from before Cockpit existed on this Mac). | One-time catch-up so your past work counts too. "Backfill" = fill in the back-catalog. |
 | `cockpit sync` | Captures and uploads once, right now. This is what the background agent runs every 15 min — you almost never type it yourself. | Named for what it does: synchronize local session files up to the dashboard. |
+| `cockpit analyze` | Runs a fresh sync, then queues batch analysis of your latest uploaded sessions. It returns immediately; status and results appear in My Work. | One command when you want newly finished work uploaded and judged now. |
 | `cockpit start --ticket <id>` | Tags your CURRENT work with a Linear ticket so sessions attribute to it. `--clear-ticket` returns to general capture. | "Start (working on) X." Agents usually run this for you per the agent rules. |
 | `cockpit login` / `cockpit pair` | Just the sign-in + device-registration step, standalone (onboard already includes it). Two names, one command: `login` is what humans guess, `pair` is what the dashboard's device screen calls it. | Recovery path when a session expires or you switch accounts. |
 | `cockpit logout` | Deletes this machine's session. | The undo of login. |
@@ -93,6 +94,23 @@ cockpit onboard --no-auth
 
 `cockpit update` installs the latest public CLI and reruns onboarding checks against saved roots. `cockpit upgrade` is the same command.
 
+## Analyze latest work
+
+```bash
+cockpit analyze --workspace "$PWD"
+```
+
+`cockpit analyze` first performs the same durable upload as `cockpit sync`. It
+queues the analysis only after that upload succeeds, then exits without waiting
+for the Fireworks batch. Use `--json` for a single machine-readable object that
+contains both the sync receipt and queued job status. The dashboard button
+analyzes the latest upload already stored by the background collector; run the
+CLI command when the work ended too recently for the 15-minute background sync.
+Each person can queue analysis once every three hours, subject to the team's
+shared `$2` UTC-day judge cap. Completion can take several minutes plus the wait
+for the next 15-minute collector poll; My Work shows queued, running, done, or
+failed status while you wait.
+
 ## Parent Mode
 
 Use a parent folder such as `~/BLI` when it contains multiple repos. Cockpit scans child git repos/worktrees, creates one stable work context per worktree, and rolls them up under repo rows in the dashboard.

package/dist/commands/local-args.js

@@ -29,6 +29,8 @@ export function parseLocalArgs(argv) {
             return parseStartArgs(argv.slice(1));
         case "sync":
             return parseSyncArgs(argv.slice(1));
+        case "analyze":
+            return parseAnalyzeArgs(argv.slice(1));
         case "backfill":
             return parseBackfillArgs(argv.slice(1));
         case "status":
@@ -302,6 +304,12 @@ function parseStartArgs(args) {
     };
 }
 function parseSyncArgs(args) {
+    return parseSyncLikeArgs(args, "sync");
+}
+function parseAnalyzeArgs(args) {
+    return parseSyncLikeArgs(args, "analyze");
+}
+function parseSyncLikeArgs(args, command) {
     const values = parseNamedArgs(args, {
         allowedFlags: [
             "--home",
@@ -321,9 +329,9 @@ function parseSyncArgs(args) {
             "--max-repos",
         ],
     });
-    assertNoPositionals(values.positionals, "sync");
+    assertNoPositionals(values.positionals, command);
     return {
-        kind: "sync",
+        kind: command,
         homeDir: optionalNonEmpty(values.flags.get("--home")),
         repoRoot: optionalNonEmpty(workRootFlagValue(values)),
         dashboardUrl: optionalUrl(values.flags.get("--dashboard-url")),

package/dist/commands/local.js

@@ -30,6 +30,7 @@ export const rootCommandNames = new Set([
     "logout",
     "start",
     "sync",
+    "analyze",
     "backfill",
     "status",
     "sessions",
@@ -76,6 +77,8 @@ export async function runLocalCockpitCli(argv, io = defaultIo()) {
                 return await runStart(command, io);
             case "sync":
                 return await runSync(command, io);
+            case "analyze":
+                return await runAnalyze(command, io);
             case "backfill":
                 return await runBackfillCommand(command, io);
             case "status":
@@ -112,6 +115,7 @@ export function localCommandHelp(command) {
         "  cockpit logout",
         "  cockpit start [--ticket <id>|--clear-ticket] [--topic <label>] [--intent <intent>] [--phase <phase>] [--workspace <path>] [--branch <name>] [--max-depth <n>] [--max-repos <n>] [--json]",
         "  cockpit sync [--workspace <path>] [--dashboard-url <url>] [--max-depth <n>] [--max-repos <n>] [--json]",
+        "  cockpit analyze [--workspace <path>] [--dashboard-url <url>] [--max-depth <n>] [--max-repos <n>] [--json]",
         "  cockpit backfill (--since-days <n>|--all) [--source codex|claude] [--dry-run] [--max-files <n>] [--yes] [--workspace <path>] [--json]",
         "  cockpit status [--workspace <path>] [--max-depth <n>] [--max-repos <n>] [--json]",
         "  cockpit sessions [--source codex|claude] [--since-days <n>|--all] [--workspace <path>] [--max-depth <n>] [--max-repos <n>] [--json]",
@@ -236,6 +240,17 @@ function localSubcommandHelp(command) {
                 "--max-depth and --max-repos.",
             ],
         ],
+        [
+            "analyze",
+            [
+                "Usage: cockpit analyze [--workspace <path>] [--dashboard-url <url>] [--json]",
+                "",
+                "Uploads the latest local ambient evidence, then queues one analysis job.",
+                "The command returns after the batch is queued; view status and results in My Work.",
+                "Omit --dashboard-url for production; pass it only for staging/custom dashboards.",
+                "`--repo <path>` remains supported as a backward-compatible alias.",
+            ],
+        ],
         [
             "backfill",
             [
@@ -1825,6 +1840,137 @@ async function runSyncLocked(command, io) {
     writeLine(io.stderr, `Retry: ${result.retry_command}`);
     return 1;
 }
+async function runAnalyze(command, io) {
+    const syncStdout = [];
+    const syncStderr = [];
+    const syncIo = {
+        ...io,
+        stdout: bufferedWritable(syncStdout),
+        stderr: bufferedWritable(syncStderr),
+    };
+    const syncCommand = {
+        ...command,
+        kind: "sync",
+        json: true,
+    };
+    const syncExitCode = await runSync(syncCommand, syncIo);
+    const syncOutput = parseCapturedJson(syncStdout);
+    if (syncExitCode !== 0 || !isUploadedSyncResult(syncOutput)) {
+        if (command.json) {
+            writeLine(io.stdout, JSON.stringify({
+                status: syncExitCode === 0 ? "sync_not_completed" : "sync_failed",
+                sync: syncOutput,
+                error: syncStderr.join("").trim()
+                    || (syncExitCode === 0
+                        ? "Cockpit sync did not upload fresh evidence."
+                        : "Cockpit sync failed."),
+            }, null, 2));
+        }
+        else {
+            replayCaptured(io.stderr, syncStderr);
+            writeLine(io.stderr, syncExitCode === 0
+                ? "Analysis was not queued because a fresh upload did not complete."
+                : "Analysis was not queued because the latest upload failed.");
+        }
+        return syncExitCode === 0 ? 1 : syncExitCode;
+    }
+    const paths = getCollectorRuntimePaths(command.homeDir);
+    const session = await readLocalCollectorSessionFile(paths).catch(() => {
+        throw new Error("Cockpit is not signed in. Run `cockpit onboard` or `cockpit login` first.");
+    });
+    const dashboardUrl = normalizeUrl(command.dashboardUrl ?? session.dashboard_url ?? DEFAULT_DASHBOARD_URL);
+    const response = await io.fetch(`${dashboardUrl}/api/ambient/analyze`, {
+        method: "POST",
+        headers: {
+            authorization: `Bearer ${session.device_token}`,
+            "content-type": "application/json",
+        },
+        body: "{}",
+    });
+    const body = await readAnalyzeApiResponse(response);
+    if (!response.ok) {
+        const message = typeof body.message === "string"
+            ? body.message
+            : `Analysis request failed with HTTP ${response.status}.`;
+        if (command.json) {
+            writeLine(io.stdout, JSON.stringify({
+                status: "analyze_failed",
+                sync: syncOutput,
+                http_status: response.status,
+                code: typeof body.code === "string" ? body.code : null,
+                message,
+                retry_after_seconds: typeof body.retry_after_seconds === "number"
+                    ? body.retry_after_seconds
+                    : null,
+            }, null, 2));
+        }
+        else {
+            replayCaptured(io.stderr, syncStderr);
+            writeLine(io.stderr, `Analysis was not queued: ${message}`);
+        }
+        return 1;
+    }
+    const jobId = typeof body.job?.id === "string" ? body.job.id : null;
+    const jobStatus = typeof body.job?.status === "string" ? body.job.status : "pending";
+    if (command.json) {
+        writeLine(io.stdout, JSON.stringify({
+            status: "queued",
+            sync: syncOutput,
+            job: body.job ?? null,
+            dashboard_url: `${dashboardUrl}/my-work`,
+        }, null, 2));
+        return 0;
+    }
+    replayCaptured(io.stderr, syncStderr);
+    writeLine(io.stdout, "Cockpit latest evidence uploaded.");
+    writeLine(io.stdout, "Cockpit analysis queued.");
+    if (jobId)
+        writeLine(io.stdout, `Job: ${jobId}`);
+    writeLine(io.stdout, `Status: ${jobStatus === "pending" ? "queued" : jobStatus}`);
+    writeLine(io.stdout, `Results: ${dashboardUrl}/my-work`);
+    return 0;
+}
+async function readAnalyzeApiResponse(response) {
+    const text = await response.text();
+    if (!text)
+        return {};
+    try {
+        const value = JSON.parse(text);
+        return value && typeof value === "object" ? value : {};
+    }
+    catch {
+        return {};
+    }
+}
+function parseCapturedJson(chunks) {
+    const text = chunks.join("").trim();
+    if (!text)
+        return null;
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        return text;
+    }
+}
+function isUploadedSyncResult(value) {
+    return Boolean(value
+        && typeof value === "object"
+        && !Array.isArray(value)
+        && value["status"] === "uploaded");
+}
+function bufferedWritable(chunks) {
+    return {
+        write(chunk) {
+            chunks.push(typeof chunk === "string" ? chunk : Buffer.from(chunk).toString("utf8"));
+            return true;
+        },
+    };
+}
+function replayCaptured(stream, chunks) {
+    for (const chunk of chunks)
+        stream.write(chunk);
+}
 async function runSyncRawEvidenceGc(command, io) {
     return runRawEvidenceLocalGc(getCollectorRuntimePaths(command.homeDir), io.env);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bli-cockpit/cli",
-  "version": "0.2.3",
+  "version": "0.2.4",
   "private": false,
   "type": "module",
   "bin": {