@sweny-ai/core 0.1.0 → 0.1.1

package/dist/claude.d.ts

@@ -36,6 +36,7 @@ export declare class ClaudeClient implements Claude {
         context: Record<string, unknown>;
         tools: Tool[];
         outputSchema?: JSONSchema;
+        onProgress?: (message: string) => void;
     }): Promise<NodeResult>;
     evaluate(opts: {
         question: string;

package/dist/claude.js

@@ -28,7 +28,7 @@ export class ClaudeClient {
         this.mcpServers = opts.mcpServers ?? {};
     }
     async run(opts) {
-        const { instruction, context, tools, outputSchema } = opts;
+        const { instruction, context, tools, outputSchema, onProgress } = opts;
         const toolCalls = [];
         // Convert core tools to SDK MCP tools
         const sdkTools = tools.map((t) => coreToolToSdkTool(t, this.defaultContext, toolCalls));
@@ -67,7 +67,22 @@ export class ClaudeClient {
                 },
             });
             for await (const message of stream) {
-                if (message.type === "result") {
+                if (message.type === "tool_progress") {
+                    const tp = message;
+                    if (tp.tool_name && typeof tp.elapsed_time_seconds === "number") {
+                        const name = stripMcpPrefix(tp.tool_name);
+                        const secs = Math.round(tp.elapsed_time_seconds);
+                        onProgress?.(`${name} (${secs}s)`);
+                    }
+                }
+                else if (message.type === "tool_use_summary") {
+                    const ts = message;
+                    if (ts.summary) {
+                        const clean = ts.summary.replace(/\n/g, " ").trim();
+                        onProgress?.(clean.length > 80 ? clean.slice(0, 79) + "\u2026" : clean);
+                    }
+                }
+                else if (message.type === "result") {
                     const resultMsg = message;
                     if (resultMsg.subtype === "success" && "result" in resultMsg) {
                         response = resultMsg.result;
@@ -233,6 +248,13 @@ function jsonPropertyToZod(prop) {
         }
     }
 }
+/** Strip MCP server prefix: "mcp__server__tool" → "tool" */
+function stripMcpPrefix(name) {
+    const parts = name.split("__");
+    if (parts.length >= 3 && parts[0] === "mcp")
+        return parts.slice(2).join("__");
+    return name;
+}
 // ─── JSON extraction ────────────────────────────────────────────
 /**
  * Extract a JSON object from Claude's text response.

package/dist/cli/config.d.ts

@@ -49,6 +49,7 @@ export interface CliConfig {
     repository: string;
     repositoryOwner: string;
     json: boolean;
+    stream: boolean;
     bell: boolean;
     cacheDir: string;
     cacheTtl: number;

package/dist/cli/config.js

@@ -55,6 +55,7 @@ export function registerTriageCommand(program) {
         .option("--betterstack-table-name <name>", 'Better Stack ClickHouse table name, e.g. "t273774.my_source"')
         .option("--gitlab-base-url <url>", "GitLab base URL (default: https://gitlab.com)")
         .option("--json", "Output results as JSON", false)
+        .option("--stream", "Stream NDJSON events to stdout (for Studio / automation)", false)
         .option("--bell", "Ring terminal bell on completion", false)
         .option("--cache-dir <path>", "Step cache directory (default: .sweny/cache)")
         .option("--cache-ttl <seconds>", "Cache TTL in seconds, 0 = infinite (default: 86400)")
@@ -126,6 +127,7 @@ export function parseCliInputs(options, fileConfig = {}) {
         repositoryOwner: env.GITHUB_REPOSITORY_OWNER || "",
         // Per-invocation flags: CLI only
         json: Boolean(options.json),
+        stream: Boolean(options.stream),
         bell: Boolean(options.bell),
         cacheDir: options.cacheDir || env.SWENY_CACHE_DIR || f("cache-dir") || ".sweny/cache",
         cacheTtl: parseInt(String(options.cacheTtl || f("cache-ttl") || "86400"), 10),
@@ -528,7 +530,8 @@ export function registerImplementCommand(program) {
         .option("--output-dir <path>", "Output directory for file providers (default: .sweny/output)")
         .option("--workspace-tools <tools>", "Comma-separated workspace tool integrations to enable (slack, notion, pagerduty, monday)")
         .option("--review-mode <mode>", "PR merge behavior: auto (GitHub auto-merge when CI passes) | review (human approval, default)", "review")
-        .option("--additional-instructions <text>", "Extra instructions for the coding agent");
+        .option("--additional-instructions <text>", "Extra instructions for the coding agent")
+        .option("--stream", "Stream NDJSON events to stdout (for Studio / automation)", false);
 }
 /**
  * Parse a JSON string into MCP server configs.

package/dist/cli/main.d.ts

@@ -3,6 +3,7 @@ import type { Workflow } from "../types.js";
 export declare function loadWorkflowFile(filePath: string): Workflow;
 export declare function workflowRunAction(file: string, options: Record<string, unknown> & {
     json?: boolean;
+    stream?: boolean;
 }): Promise<void>;
 export declare function workflowExportAction(name: string): void;
 export declare function workflowValidateAction(file: string, options: {

package/dist/cli/main.js

@@ -22,6 +22,28 @@ import { registerTriageCommand, registerImplementCommand, parseCliInputs, valida
 import { c, formatBanner, getStepDetails, formatStepLine, formatDagResultHuman, formatResultJson, formatValidationErrors, formatCrashError, formatCheckResults, } from "./output.js";
 import { checkProviderConnectivity } from "./check.js";
 import { registerSetupCommand } from "./setup.js";
+// ── Stream observer (NDJSON) ────────────────────────────────────────
+/**
+ * Create an observer that writes NDJSON ExecutionEvents to stdout.
+ * Studio and other consumers parse these line-by-line.
+ */
+function createStreamObserver() {
+    return (event) => {
+        process.stdout.write(JSON.stringify(event) + "\n");
+    };
+}
+/** Compose multiple observers into one. */
+function composeObservers(...observers) {
+    const valid = observers.filter((o) => o != null);
+    if (valid.length === 0)
+        return undefined;
+    if (valid.length === 1)
+        return valid[0];
+    return (event) => {
+        for (const o of valid)
+            o(event);
+    };
+}
 // Auto-load .env before Commander parses (so env vars are available for defaults)
 loadDotenv();
 const program = new Command()
@@ -137,16 +159,17 @@ triageCmd.action(async (options) => {
         cwd: process.cwd(),
         logger: consoleLogger,
     });
-    // ── Spinner state ──────────────────────────────────────────
+    // ── Progress display state ─────────────────────────────────
     const FRAMES = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
     const isTTY = !config.json && (process.stderr.isTTY ?? false);
+    const MAX_ACTIVITY = 3;
     let spinnerInterval;
     let spinnerActive = false;
     let frameIdx = 0;
     let stepStart = 0;
     let stepLabel = "";
-    let spinnerStatus = "";
-    let currentPhaseColor = chalk.cyan;
+    let recentActivity = [];
+    let renderedLines = 0; // how many lines the progress block currently occupies
     let stepIndex = 0;
     const totalNodes = Object.keys(triageWorkflow.nodes).length;
     function formatElapsed(ms) {
@@ -156,33 +179,38 @@ triageCmd.action(async (options) => {
         const m = Math.floor(s / 60);
         return `${m}m ${s % 60}s`;
     }
-    function clearSpinnerLine() {
-        if (spinnerActive && isTTY) {
-            process.stderr.write("\r\x1b[K");
+    /** Render the multi-line progress block (spinner + activity lines). */
+    function renderProgressBlock() {
+        const cols = process.stderr.columns || 80;
+        const frame = chalk.cyan(FRAMES[frameIdx++ % FRAMES.length]);
+        const counter = c.subtle(`[${stepIndex}/${totalNodes}]`);
+        const elapsed = c.subtle(formatElapsed(Date.now() - stepStart));
+        const headerLine = `  ${frame} ${counter} ${stepLabel}  ${elapsed}`;
+        const lines = [headerLine];
+        for (const msg of recentActivity) {
+            // Truncate to terminal width
+            const line = `    ${c.subtle("\u21B3")} ${c.subtle(msg)}`;
+            const vis = line.replace(/\x1B\[[0-9;]*m/g, "").length;
+            lines.push(vis > cols ? line.slice(0, cols - 1) : line);
+        }
+        // Move cursor up to clear previous render, then clear to end of screen
+        if (renderedLines > 0) {
+            process.stderr.write(`\x1B[${renderedLines}A\x1B[J`);
         }
+        process.stderr.write(lines.join("\n") + "\n");
+        renderedLines = lines.length;
     }
     function startSpinner(label) {
         stepStart = Date.now();
         stepLabel = label;
-        spinnerStatus = "";
+        recentActivity = [];
         frameIdx = 0;
         spinnerActive = true;
+        renderedLines = 0;
         if (isTTY) {
-            const cols = process.stderr.columns || 80;
-            spinnerInterval = setInterval(() => {
-                const frame = currentPhaseColor(FRAMES[frameIdx++ % FRAMES.length]);
-                const counter = c.subtle(`[${stepIndex}/${totalNodes}]`);
-                const elapsed = c.subtle(formatElapsed(Date.now() - stepStart));
-                const status = spinnerStatus ? ` ${c.subtle("\u2014")} ${c.subtle(spinnerStatus)}` : "";
-                // Truncate to terminal width to prevent line wrapping
-                let line = `  ${frame} ${counter} ${stepLabel}${status} ${elapsed}`;
-                const visibleLen = line.replace(/\x1B\[[0-9;]*m/g, "").length;
-                if (visibleLen > cols) {
-                    // Re-render without status if too wide
-                    line = `  ${frame} ${counter} ${stepLabel} ${elapsed}`;
-                }
-                process.stderr.write(`\r\x1b[K${line}`);
-            }, 80);
+            process.stderr.write("\x1B[?25l"); // hide cursor
+            renderProgressBlock();
+            spinnerInterval = setInterval(() => renderProgressBlock(), 100);
         }
         else if (!config.json) {
             spinnerInterval = setInterval(() => {
@@ -196,59 +224,59 @@ triageCmd.action(async (options) => {
             clearInterval(spinnerInterval);
             spinnerInterval = undefined;
         }
-        if (isTTY) {
-            process.stderr.write("\r\x1b[K");
+        if (isTTY && renderedLines > 0) {
+            process.stderr.write(`\x1B[${renderedLines}A\x1B[J`);
+            process.stderr.write("\x1B[?25h"); // show cursor
+            renderedLines = 0;
         }
         spinnerActive = false;
     }
     // ── Build observer for DAG events ──────────────────────────
     const runStart = Date.now();
-    const observer = config.json
+    const progressObserver = config.json
         ? undefined
         : (event) => {
             switch (event.type) {
                 case "workflow:start":
-                    // Already printed the banner
                     break;
                 case "node:enter":
                     stepIndex++;
-                    if (!config.json) {
-                        startSpinner(event.node);
+                    startSpinner(event.node);
+                    break;
+                case "node:progress":
+                    if (spinnerActive) {
+                        recentActivity.push(event.message);
+                        if (recentActivity.length > MAX_ACTIVITY)
+                            recentActivity.shift();
                     }
                     break;
                 case "tool:call":
-                    if (spinnerActive && isTTY) {
-                        spinnerStatus = `${event.tool}(...)`;
-                    }
+                    // tool:call is now superseded by the richer node:progress events
                     break;
                 case "node:exit": {
                     stopSpinner();
-                    if (!config.json) {
-                        const elapsed = formatElapsed(Date.now() - stepStart);
-                        const icon = event.result.status === "success"
-                            ? c.ok("\u2713")
-                            : event.result.status === "skipped"
-                                ? c.subtle("\u2212")
-                                : c.fail("\u2717");
-                        const reason = event.result.status !== "success" ? event.result.data?.error : undefined;
-                        const counter = `[${stepIndex}/${totalNodes}]`;
-                        console.log(formatStepLine(icon, counter, event.node, elapsed, reason));
-                        // Inline data details
-                        const details = getStepDetails(event.node, event.result.data);
-                        for (const detail of details) {
-                            console.log(`    ${c.subtle("\u21B3")} ${c.subtle(detail)}`);
-                        }
+                    const elapsed = formatElapsed(Date.now() - stepStart);
+                    const icon = event.result.status === "success"
+                        ? c.ok("\u2713")
+                        : event.result.status === "skipped"
+                            ? c.subtle("\u2212")
+                            : c.fail("\u2717");
+                    const reason = event.result.status !== "success" ? event.result.data?.error : undefined;
+                    const counter = `[${stepIndex}/${totalNodes}]`;
+                    console.log(formatStepLine(icon, counter, event.node, elapsed, reason));
+                    const details = getStepDetails(event.node, event.result.data);
+                    for (const detail of details) {
+                        console.log(`    ${c.subtle("\u21B3")} ${c.subtle(detail)}`);
                     }
                     break;
                 }
                 case "route":
-                    // Optionally log routing decisions
                     break;
                 case "workflow:end":
-                    // Output is handled after execute() returns
                     break;
             }
         };
+    const observer = composeObservers(progressObserver, config.stream ? createStreamObserver() : undefined);
     // ── Build workflow input from config ──────────────────────
     // TODO: The triage workflow input structure may need further refinement
     // once the workflow nodes have stabilized. For now, pass config fields
@@ -328,7 +356,7 @@ implementCmd.action(async (issueId, options) => {
     });
     console.log(chalk.cyan(`\n  sweny implement ${issueId}\n`));
     const isTTY = process.stderr.isTTY ?? false;
-    const observer = (event) => {
+    const implProgressObserver = (event) => {
         switch (event.type) {
             case "workflow:start":
                 process.stderr.write(`\n  \u25B2 ${chalk.bold(event.workflow)}\n\n`);
@@ -355,6 +383,7 @@ implementCmd.action(async (issueId, options) => {
                 break;
         }
     };
+    const observer = composeObservers(implProgressObserver, Boolean(options.stream) ? createStreamObserver() : undefined);
     // Build workflow input for implement
     const workflowInput = {
         issueIdentifier: issueId,
@@ -446,7 +475,7 @@ export async function workflowRunAction(file, options) {
     });
     // Track per-node entry time to compute elapsed on exit
     const nodeEnterTimes = new Map();
-    const observer = isJson
+    const wfProgressObserver = isJson
         ? undefined
         : (event) => {
             switch (event.type) {
@@ -467,7 +496,6 @@ export async function workflowRunAction(file, options) {
                     const elapsedMs = Date.now() - enterTime;
                     const elapsed = chalk.dim(elapsedMs < 1000 ? `${elapsedMs}ms` : `${Math.round(elapsedMs / 100) / 10}s`);
                     if (isTTY) {
-                        // Overwrite the pending "○ nodeId…" line with the final status
                         process.stderr.write(`\x1B[1A\x1B[2K  ${icon} ${event.node}  ${elapsed}\n`);
                     }
                     else {
@@ -480,6 +508,7 @@ export async function workflowRunAction(file, options) {
                     break;
             }
         };
+    const observer = composeObservers(wfProgressObserver, options.stream ? createStreamObserver() : undefined);
     // Build workflow input from config
     const workflowInput = {
         timeRange: config.timeRange,
@@ -587,6 +616,7 @@ workflowCmd
     .description("Run a workflow from a YAML or JSON file")
     .option("--dry-run", "Validate workflow without running")
     .option("--json", "Output result as JSON on stdout; suppress progress output")
+    .option("--stream", "Stream NDJSON events to stdout (for Studio / automation)")
     .action(workflowRunAction);
 workflowCmd
     .command("export <name>")

package/dist/executor.js

@@ -52,6 +52,9 @@ export async function execute(workflow, input, options) {
             context,
             tools: trackedTools,
             outputSchema: node.output,
+            onProgress: (message) => {
+                safeObserve(observer, { type: "node:progress", node: currentId, message }, logger);
+            },
         });
         results.set(currentId, result);
         safeObserve(observer, { type: "node:exit", node: currentId, result }, logger);

package/dist/types.d.ts

@@ -91,6 +91,10 @@ export type ExecutionEvent = {
     type: "node:exit";
     node: string;
     result: NodeResult;
+} | {
+    type: "node:progress";
+    node: string;
+    message: string;
 } | {
     type: "route";
     from: string;
@@ -108,6 +112,8 @@ export interface Claude {
         context: Record<string, unknown>;
         tools: Tool[];
         outputSchema?: JSONSchema;
+        /** Called with status messages while Claude is working (tool name, etc.) */
+        onProgress?: (message: string) => void;
     }): Promise<NodeResult>;
     /** Evaluate a routing condition — pick one of N choices */
     evaluate(opts: {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sweny-ai/core",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "type": "module",
   "bin": {
     "sweny": "./dist/cli/main.js"