@moda-ai/cli 1.17.1 → 1.18.0

package/dist/harness.d.ts

@@ -1,3 +1,4 @@
+import { type AnalystTuiEvent } from './analyst-tui.js';
 import type { CommandContext } from './command-context.js';
 import type { HarnessReport } from './harness-report.js';
 declare const SCHEMA_VERSION = "harness.v0.1";
@@ -271,6 +272,34 @@ export declare function writeHarnessAnalyzeResult(context: CommandContext, paylo
  */
 export declare function emitWrittenArtifacts(context: CommandContext, written: string[], description: string): void;
 export declare function repairExternalAnalystReport(report: HarnessReport, rootDir: string): HarnessReport;
+/**
+ * A parsed coding-agent stream event handed to `onAgentEvent` consumers.
+ * Extends the analyst TUI event with an optional `detail` (file path or
+ * command extracted from tool input) so callers can render richer one-line
+ * progress cards. The analyst TUI ignores the extra field.
+ */
+export type CodingAgentEvent = AnalystTuiEvent & {
+    detail?: string;
+};
+/**
+ * Translate a parsed coding-agent stream event into a one-line progress card
+ * ("editing src/llm/client.ts", "running bun add moda-ai", trimmed agent text).
+ * Returns undefined for low-signal events (system noise) so they never reach
+ * the user. Shared by the init progress board (via sdk-integration) and the
+ * agent-stream analyst progress events below.
+ */
+export declare function describeCodingAgentEvent(event: CodingAgentEvent): string | undefined;
+/**
+ * Map a parsed analyst stream event to the `progress` agent event the CLI
+ * writes in agent-stream mode. Tool/command events get a `tool_use` phase so
+ * downstream consumers (the hosted analyze runner's progress parser counts
+ * phases starting with "tool") can track tool-call activity; agent text gets
+ * the generic `analyst` phase. Low-signal events map to undefined.
+ */
+export declare function analystEventProgress(event: CodingAgentEvent): {
+    phase: string;
+    message: string;
+} | undefined;
 export declare function sleep(ms: number): Promise<void>;
 export declare function summarizeInvalidAnalystReport(report: unknown): Record<string, unknown>;
 /**
@@ -306,6 +335,12 @@ export declare function runCodingAgent(options: {
     timeoutMs?: number;
     progressToStderr?: boolean;
     onProgress?: (message: string, phase?: string) => void;
+    /**
+     * Receive parsed agent stream events incrementally while output stays
+     * buffered. Requires the streaming invocation, so passing it defaults
+     * `stream` to true when not set explicitly.
+     */
+    onAgentEvent?: (event: CodingAgentEvent) => void;
 }): Promise<CodingAgentRun>;
 export declare function truncateText(value: string, maxLength: number): string;
 export declare function scanHarness(options?: ScanOptions): HarnessGraph;

package/dist/harness.js

@@ -8,7 +8,7 @@ import { callControlAPI } from './api-client.js';
 import { AnalystTui, shouldUseAnalystTui } from './analyst-tui.js';
 import { resolveApiKey, resolveTenantId } from './config.js';
 import { CliInputError, CliInputRequiredError } from './errors.js';
-import { isRemoteHarnessAnalyze, runRemoteHarnessAnalyst } from './harness-remote.js';
+import { HARNESS_REMOTE_RUN_STATE_PATH, isRemoteHarnessAnalyze, readRemoteRunState, runHarnessPull, runRemoteHarnessAnalyst, } from './harness-remote.js';
 import { getActiveProfile } from './profiles.js';
 import { enrichScanCaptureMetadata, annotatedSourceCandidates, extractToolBody, hydratePromptAndToolBodies, readPromptOrToolBody, resolveAnnotatedSourcePath, } from './harness-artifact-bodies.js';
 import { approveHarnessReport, createHarnessReport, graphForReport, hashHarnessReport, hashStableJson as hashHarnessReportStableJson, HARNESS_REPORT_PATH, loadHarnessReportForSync, normalizeHarnessReport, readHarnessReport, resolveHarnessReportPath, validateHarnessReport, writeHarnessReportArtifacts, } from './harness-report.js';
@@ -325,6 +325,9 @@ export async function runHarnessCommand(context) {
             });
             return { exitCode: validation.status === 'pass' ? 0 : 1 };
         }
+        case 'pull': {
+            return runHarnessPull({ context, rootDir, scanPlan });
+        }
         case 'validate-report': {
             const reportPath = resolveHarnessReportPath(rootDir, context.positionals[1] ?? context.flags.report);
             const report = readHarnessReport(reportPath);
@@ -411,11 +414,20 @@ export async function runHarnessCommand(context) {
                 });
             const currentGraphHash = hashStableJson(graphForSync(graph));
             const syncState = readHarnessSyncState(rootDir);
+            const remoteRun = readRemoteRunState(rootDir);
             context.output.writeData({
                 manifest: HARNESS_PATH,
                 exists: existsSync(manifestPath),
                 summary: summarizeHarness(graph),
                 graphHash: currentGraphHash,
+                remoteRun: remoteRun
+                    ? {
+                        statePath: HARNESS_REMOTE_RUN_STATE_PATH,
+                        runId: remoteRun.run_id,
+                        status: remoteRun.status,
+                        startedAt: remoteRun.started_at_iso || undefined,
+                    }
+                    : undefined,
                 sync: syncState
                     ? {
                         statePath: SYNC_STATE_PATH,
@@ -439,7 +451,7 @@ export async function runHarnessCommand(context) {
             return { exitCode: 0 };
         }
         default:
-            throw new CliInputError(`Unknown harness command '${subcommand}'.`, 'Usage: moda harness analyze|validate-report|approve|scan|sync|agents|graph|explain|write-summary|status');
+            throw new CliInputError(`Unknown harness command '${subcommand}'.`, 'Usage: moda harness analyze|pull|validate-report|approve|scan|sync|agents|graph|explain|write-summary|status');
     }
 }
 export function writeHarnessAnalyzeResult(context, payload) {
@@ -527,12 +539,17 @@ async function runExternalHarnessAnalyst(options) {
         rootDir: options.rootDir,
         tenantId: options.tenant?.tenantId,
     });
+    // Agent-stream mode also runs the analyst child in stream-json mode so its
+    // tool activity can be forwarded as NDJSON `progress` events (consumed by
+    // the hosted analyze runner for live run-state progress). Report extraction
+    // is unaffected: the report is read from .moda/harness-report.json.
+    const streamAnalystProgress = options.context.outputMode === 'agent-stream';
     const invocation = resolveExternalHarnessAnalystInvocation({
         adapter: options.adapter,
         flags: options.context.flags,
         prompt,
         rootDir: options.rootDir,
-        stream: options.context.outputMode === 'human',
+        stream: options.context.outputMode === 'human' || streamAnalystProgress,
     });
     options.context.output.writeEvent({
         event: 'progress',
@@ -584,6 +601,22 @@ async function runExternalHarnessAnalyst(options) {
                     elapsed_ms: Date.now() - options.context.startedAt,
                 });
             },
+            // Forward the analyst's parsed tool/text events as progress events so
+            // agent-stream consumers see live activity ("reading src/agent.ts"),
+            // not just the periodic still-investigating ticker.
+            onAgentEvent: streamAnalystProgress
+                ? (event) => {
+                    const progress = analystEventProgress(event);
+                    if (!progress)
+                        return;
+                    options.context.output.writeEvent({
+                        event: 'progress',
+                        phase: progress.phase,
+                        message: progress.message,
+                        elapsed_ms: Date.now() - options.context.startedAt,
+                    });
+                }
+                : undefined,
         });
         if (result.error) {
             throw new CliInputError(`Harness analyst ${options.adapter} failed to run: ${result.error.message}`, 'Check that the selected coding agent CLI is installed and authenticated, or run `moda harness analyze --analyst=local-scan` for the deterministic fallback.');
@@ -835,6 +868,68 @@ function extractTextFromAgentEvent(event) {
 function escapeRegExp(value) {
     return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
 }
+/**
+ * Tool cards must stay one line (same convention as ask-stream's oneLine):
+ * collapse whitespace and truncate so multi-line agent prose never spills
+ * into a progress line.
+ */
+const EVENT_CARD_MAX = 100;
+function eventCardLine(text) {
+    const collapsed = text.replace(/\s+/g, ' ').trim();
+    return collapsed.length > EVENT_CARD_MAX
+        ? `${collapsed.slice(0, EVENT_CARD_MAX - 1)}…`
+        : collapsed;
+}
+/**
+ * Translate a parsed coding-agent stream event into a one-line progress card
+ * ("editing src/llm/client.ts", "running bun add moda-ai", trimmed agent text).
+ * Returns undefined for low-signal events (system noise) so they never reach
+ * the user. Shared by the init progress board (via sdk-integration) and the
+ * agent-stream analyst progress events below.
+ */
+export function describeCodingAgentEvent(event) {
+    if (event.kind === 'tool') {
+        const name = event.toolName ?? 'tool';
+        const detail = event.detail;
+        if (/edit|write|patch|create|notebook/i.test(name)) {
+            return eventCardLine(detail ? `editing ${detail}` : `editing files (${name})`);
+        }
+        if (/bash|shell|exec|command|terminal|run/i.test(name)) {
+            return eventCardLine(detail ? `running ${detail}` : `running a command (${name})`);
+        }
+        if (/read|grep|glob|search|ls|find|cat/i.test(name)) {
+            return eventCardLine(detail ? `reading ${detail}` : `reading files (${name})`);
+        }
+        return eventCardLine(detail ? `using ${name}: ${detail}` : `using ${name}`);
+    }
+    if (event.kind === 'command') {
+        const command = event.detail ?? event.message.replace(/^command\s+/, '');
+        return eventCardLine(`running ${command}`);
+    }
+    if (event.kind === 'agent_text') {
+        const text = eventCardLine(event.message);
+        return text.length > 0 ? text : undefined;
+    }
+    if (event.kind === 'rate_limit')
+        return 'waiting on a provider rate limit';
+    return undefined;
+}
+/**
+ * Map a parsed analyst stream event to the `progress` agent event the CLI
+ * writes in agent-stream mode. Tool/command events get a `tool_use` phase so
+ * downstream consumers (the hosted analyze runner's progress parser counts
+ * phases starting with "tool") can track tool-call activity; agent text gets
+ * the generic `analyst` phase. Low-signal events map to undefined.
+ */
+export function analystEventProgress(event) {
+    const card = describeCodingAgentEvent(event);
+    if (!card)
+        return undefined;
+    return {
+        phase: event.kind === 'tool' || event.kind === 'command' ? 'tool_use' : 'analyst',
+        message: card,
+    };
+}
 function runExternalAnalystProcess(invocation, options) {
     return new Promise((resolveProcess) => {
         const child = spawn(invocation.command, invocation.args, {
@@ -889,22 +984,22 @@ function runExternalAnalystProcess(invocation, options) {
                 stdout += text;
             else
                 stderr += text;
-            if (options.inheritedOutput) {
-                if (options.tui && stream === 'stderr') {
-                    recordExternalAgentTextChunk(text, options.tui);
-                }
-                else if (options.streamEvents && stream === 'stdout') {
-                    eventLineBuffer += text;
-                    const lines = eventLineBuffer.split(/\r?\n/);
-                    eventLineBuffer = lines.pop() ?? '';
-                    for (const line of lines) {
-                        recordExternalAgentEventLine(line, options);
-                    }
-                }
-                else {
-                    process.stderr.write(chunk);
+            const wantsEventLines = options.streamEvents && stream === 'stdout' &&
+                (options.inheritedOutput || Boolean(options.onAgentEvent));
+            if (options.inheritedOutput && options.tui && stream === 'stderr') {
+                recordExternalAgentTextChunk(text, options.tui);
+            }
+            else if (wantsEventLines) {
+                eventLineBuffer += text;
+                const lines = eventLineBuffer.split(/\r?\n/);
+                eventLineBuffer = lines.pop() ?? '';
+                for (const line of lines) {
+                    recordExternalAgentEventLine(line, options);
                 }
             }
+            else if (options.inheritedOutput) {
+                process.stderr.write(chunk);
+            }
             if (stdout.length + stderr.length > options.maxBuffer && !maxBufferExceeded) {
                 maxBufferExceeded = true;
                 child.kill('SIGTERM');
@@ -994,6 +1089,9 @@ function recordExternalAgentEventLine(line, options) {
     const event = parseExternalAgentEventLine(line);
     if (!event)
         return;
+    options.onAgentEvent?.(event);
+    if (!options.inheritedOutput)
+        return;
     options.tui?.recordEvent(event);
     if (options.tui)
         return;
@@ -1036,7 +1134,8 @@ function parseExternalAgentEvent(event) {
         stringValue(event.toolName) ??
         stringValue(call?.name);
     if (toolName && /tool|call|exec|command|bash/i.test(`${type ?? ''} ${subtype ?? ''}`)) {
-        return { kind: 'tool', toolName, message: `tool ${toolName}` };
+        const detail = toolInputDetail(event.input ?? event.arguments ?? call?.input ?? call?.arguments);
+        return { kind: 'tool', toolName, message: `tool ${toolName}`, ...(detail ? { detail } : {}) };
     }
     const directText = stringValue(event.text) ??
         stringValue(event.message) ??
@@ -1063,8 +1162,9 @@ function parseExternalAgentEvent(event) {
             return parsed;
     }
     const command = stringValue(event.command) ?? stringValue(event.cmd);
-    if (command)
-        return { kind: 'command', message: `command ${truncateText(command, 300)}` };
+    if (command) {
+        return { kind: 'command', message: `command ${truncateText(command, 300)}`, detail: truncateText(command, 300) };
+    }
     if (type && !isLowSignalEventType(type)) {
         return { kind: 'system', message: subtype ? `${type}:${subtype}` : type };
     }
@@ -1076,7 +1176,10 @@ function parseAgentContentPart(part) {
     const partType = stringValue(part.type);
     if (partType === 'tool_use' || partType === 'tool_call') {
         const name = stringValue(part.name) ?? stringValue(part.tool_name);
-        return name ? { kind: 'tool', toolName: name, message: `tool ${name}` } : undefined;
+        if (!name)
+            return undefined;
+        const detail = toolInputDetail(part.input ?? part.arguments);
+        return { kind: 'tool', toolName: name, message: `tool ${name}`, ...(detail ? { detail } : {}) };
     }
     if (partType === 'tool_result' || partType === 'tool_output')
         return undefined;
@@ -1089,6 +1192,20 @@ function parseAgentContentPart(part) {
         return { kind: 'tool', toolName: name, message: `tool ${name}` };
     return undefined;
 }
+/** Pull the most useful one-line detail (file path or command) out of a tool input payload. */
+function toolInputDetail(input) {
+    if (!isRecord(input))
+        return undefined;
+    const value = stringValue(input.file_path) ??
+        stringValue(input.filePath) ??
+        stringValue(input.path) ??
+        stringValue(input.notebook_path) ??
+        stringValue(input.command) ??
+        stringValue(input.cmd) ??
+        stringValue(input.pattern) ??
+        stringValue(input.query);
+    return value ? truncateText(firstMeaningfulLine(value), 300) : undefined;
+}
 function firstMeaningfulLine(value) {
     return value.split(/\r?\n/).map((line) => line.trim()).find(Boolean) ?? value.trim();
 }
@@ -1308,7 +1425,7 @@ export function codingAgentDisplayName(adapter) {
 }
 /** Spawn an installed coding-agent CLI with a prompt; capture its output. */
 export async function runCodingAgent(options) {
-    const stream = options.stream ?? false;
+    const stream = options.stream ?? Boolean(options.onAgentEvent);
     const invocation = resolveExternalHarnessAnalystInvocation({
         adapter: options.adapter,
         flags: {},
@@ -1331,6 +1448,7 @@ export async function runCodingAgent(options) {
         maxAttempts: externalAnalystMaxAttempts(options.adapter),
         backoffMs: numericEnvAllowZero('MODA_HARNESS_ANALYST_RETRY_BACKOFF_MS', 6_000),
         onProgress: options.onProgress,
+        onAgentEvent: options.onAgentEvent,
     });
     return {
         adapter: invocation.adapter,