@sweny-ai/core 0.1.93 → 0.1.95

package/dist/cli/main.d.ts

@@ -5,6 +5,7 @@ export declare function workflowRunAction(file: string, options: Record<string,
     json?: boolean;
     stream?: boolean;
     mermaid?: boolean;
+    verbose?: boolean;
 }): Promise<void>;
 export declare function workflowExportAction(name: string): void;
 export declare function workflowValidateAction(file: string, options: {

package/dist/cli/main.js

@@ -25,6 +25,7 @@ import { loadDotenv, loadConfigFile } from "./config-file.js";
 import { buildCredentialMap } from "./credentials.js";
 import { runNew } from "./new.js";
 import { runE2eRun } from "./e2e.js";
+import { createVerboseToolObserver } from "./verbose-observer.js";
 import { registerTriageCommand, registerImplementCommand, parseCliInputs, validateInputs, validateWarnings, } from "./config.js";
 import { c, formatBanner, getStepDetails, formatStepLine, formatDagResultHuman, formatDagResultMarkdown, formatResultJson, formatValidationErrors, formatCrashError, formatCheckResults, } from "./output.js";
 import { checkProviderConnectivity } from "./check.js";
@@ -46,6 +47,8 @@ function createStreamObserver() {
         process.stdout.write(JSON.stringify(event) + "\n");
     };
 }
+// Verbose tool-detail observer lives in ./verbose-observer.ts so tests can
+// import it without triggering main.ts's top-level CLI parser.
 /** Compose multiple observers into one. */
 function composeObservers(...observers) {
     const valid = observers.filter((o) => o != null);
@@ -753,7 +756,7 @@ export async function workflowRunAction(file, options) {
     if (wfCloudHandle?.dashboardUrl && !isJson) {
         console.log(c.subtle(`  cloud: ${wfCloudHandle.dashboardUrl}`));
     }
-    const observer = composeObservers(wfProgressObserver, options.stream ? createStreamObserver() : undefined, createCloudStreamObserver(config, wfCloudHandle));
+    const observer = composeObservers(wfProgressObserver, options.verbose ? createVerboseToolObserver() : undefined, options.stream ? createStreamObserver() : undefined, createCloudStreamObserver(config, wfCloudHandle));
     try {
         const { results, trace } = await execute(workflow, workflowInput, {
             skills,
@@ -857,6 +860,7 @@ workflowCmd
     .option("--list-nodes", "Validate, print nodes/skills, and exit without running. (Replaces the pre-Fix-#6 --dry-run behavior.)")
     .option("--json", "Output result as JSON on stdout; suppress progress output")
     .option("--stream", "Stream NDJSON events to stdout (for Studio / automation)")
+    .option("--verbose", "Print each tool call's input and output inline (human-readable, truncated). Use --stream for full untruncated NDJSON.")
     .option("--mermaid", "Output a Mermaid diagram with execution state after run")
     .option("--input <json>", "JSON string of input data to pass to the workflow")
     .action(workflowRunAction);

package/dist/cli/verbose-observer.d.ts

@@ -0,0 +1,19 @@
+import type { Observer } from "../types.js";
+/**
+ * Create an observer that prints each tool call's input and output to stderr
+ * in a human-readable form. Useful when debugging a node that fails or routes
+ * unexpectedly — the default human output only shows step transitions,
+ * leaving "why" invisible.
+ *
+ * Emission strategy: print the full call list on `node:exit` rather than per
+ * `tool:call`/`tool:result` event. The reason: the executor's tool:call and
+ * tool:result events fire only for skill-registered tools, not for the
+ * Claude Code subprocess's built-in tools (Bash, Read, Edit, etc.). Those
+ * built-in tools — the ones agents actually use most — land in
+ * `result.toolCalls` only after the node completes. Walking result.toolCalls
+ * on node:exit covers both kinds and avoids partial visibility.
+ *
+ * Inputs and outputs are truncated; use `--stream` for full untruncated
+ * NDJSON.
+ */
+export declare function createVerboseToolObserver(): Observer;

package/dist/cli/verbose-observer.js

@@ -0,0 +1,61 @@
+import chalk from "chalk";
+const TRUNCATE = 1200;
+function truncate(s) {
+    return s.length > TRUNCATE
+        ? `${s.slice(0, TRUNCATE)}\n      ${chalk.dim(`… [${s.length - TRUNCATE} more chars]`)}`
+        : s;
+}
+function fmt(v) {
+    if (v === undefined)
+        return "undefined";
+    if (v === null)
+        return "null";
+    if (typeof v === "string")
+        return v;
+    try {
+        return JSON.stringify(v, null, 2);
+    }
+    catch {
+        return String(v);
+    }
+}
+function indent(s) {
+    return s.split("\n").join("\n      ");
+}
+function printCall(call) {
+    process.stderr.write(`    ${chalk.dim("→")} ${chalk.cyan(call.tool)} ${chalk.dim("(input)")}\n`);
+    process.stderr.write(`      ${chalk.dim(indent(truncate(fmt(call.input))))}\n`);
+    const status = call.status === "error" ? chalk.red("(output, error)") : chalk.dim("(output)");
+    process.stderr.write(`    ${chalk.dim("←")} ${chalk.cyan(call.tool)} ${status}\n`);
+    process.stderr.write(`      ${chalk.dim(indent(truncate(fmt(call.output))))}\n`);
+}
+/**
+ * Create an observer that prints each tool call's input and output to stderr
+ * in a human-readable form. Useful when debugging a node that fails or routes
+ * unexpectedly — the default human output only shows step transitions,
+ * leaving "why" invisible.
+ *
+ * Emission strategy: print the full call list on `node:exit` rather than per
+ * `tool:call`/`tool:result` event. The reason: the executor's tool:call and
+ * tool:result events fire only for skill-registered tools, not for the
+ * Claude Code subprocess's built-in tools (Bash, Read, Edit, etc.). Those
+ * built-in tools — the ones agents actually use most — land in
+ * `result.toolCalls` only after the node completes. Walking result.toolCalls
+ * on node:exit covers both kinds and avoids partial visibility.
+ *
+ * Inputs and outputs are truncated; use `--stream` for full untruncated
+ * NDJSON.
+ */
+export function createVerboseToolObserver() {
+    return (event) => {
+        if (event.type !== "node:exit")
+            return;
+        const calls = event.result.toolCalls;
+        if (calls.length === 0)
+            return;
+        process.stderr.write(`    ${chalk.bold.dim(`${event.node}: ${calls.length} tool call${calls.length === 1 ? "" : "s"}`)}\n`);
+        for (const call of calls) {
+            printCall(call);
+        }
+    };
+}

package/package.json

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