@smithers-orchestrator/cli 0.16.9 → 0.17.0

package/src/mdx-plugin.js

@@ -0,0 +1,6 @@
+import { plugin } from "bun";
+import mdx from "@mdx-js/esbuild";
+
+export function mdxPlugin() {
+    plugin(mdx());
+}

package/src/output.js

@@ -8,6 +8,9 @@ import { NodeOutputRouteError } from "@smithers-orchestrator/server/gatewayRoute
 import { EXIT_OK } from "./util/exitCodes.js";
 import { formatCliErrorForStderr, getCliErrorMapping } from "./util/errorMessage.js";
 
+const RUN_ID_PATTERN = /^[a-z0-9_-]{1,64}$/;
+const NODE_ID_PATTERN = /^[a-zA-Z0-9:_-]{1,128}$/;
+
 /**
  * @param {any} response
  * @returns {string}
@@ -69,6 +72,52 @@ async function resolveLatestIteration(adapter, runId, nodeId) {
     }
 }
 
+/**
+ * @param {Record<string, unknown> | null} row
+ * @returns {Record<string, unknown> | null}
+ */
+function stripOutputKeyColumns(row) {
+    if (!row || typeof row !== "object") {
+        return null;
+    }
+    const result = { ...row };
+    delete result.run_id;
+    delete result.runId;
+    delete result.node_id;
+    delete result.nodeId;
+    delete result.iteration;
+    return result;
+}
+
+/**
+ * @param {RunOutputCommandInput} input
+ * @param {number} iteration
+ * @returns {Promise<RunOutputCommandResult>}
+ */
+async function runRawJsonOutput(input, iteration) {
+    if (!RUN_ID_PATTERN.test(input.runId)) {
+        throw new NodeOutputRouteError("InvalidRunId", "runId must match /^[a-z0-9_-]{1,64}$/.");
+    }
+    if (!NODE_ID_PATTERN.test(input.nodeId)) {
+        throw new NodeOutputRouteError("InvalidNodeId", "nodeId must match /^[a-zA-Z0-9:_-]{1,128}$/.");
+    }
+    const run = await input.adapter.getRun(input.runId);
+    if (!run) {
+        throw new NodeOutputRouteError("RunNotFound", `Run not found: ${input.runId}`);
+    }
+    const node = await input.adapter.getNode(input.runId, input.nodeId, iteration);
+    if (!node) {
+        throw new NodeOutputRouteError("NodeNotFound", `Node not found: ${input.nodeId}`);
+    }
+    const outputTable = typeof node.outputTable === "string" ? node.outputTable.trim() : "";
+    if (!outputTable) {
+        throw new NodeOutputRouteError("NodeHasNoOutput", `Node ${input.nodeId} has no output table.`);
+    }
+    const row = await input.adapter.getRawNodeOutputForIteration(outputTable, input.runId, input.nodeId, iteration);
+    input.stdout.write(`${JSON.stringify(stripOutputKeyColumns(row))}\n`);
+    return { exitCode: EXIT_OK };
+}
+
 /**
  * @param {RunOutputCommandInput} input
  * @returns {Promise<RunOutputCommandResult>}
@@ -80,6 +129,9 @@ export async function runOutputOnce(input) {
         iteration = latest ?? 0;
     }
     try {
+        if (input.json && !input.pretty) {
+            return await runRawJsonOutput(input, iteration);
+        }
         const response = await getNodeOutputRoute({
             runId: input.runId,
             nodeId: input.nodeId,

package/src/smithersRuntime.js

@@ -3,10 +3,11 @@ import { Cause, Effect, Exit, Layer, ManagedRuntime } from "effect";
 import { SchedulerLive, WorkflowSessionLive } from "@smithers-orchestrator/scheduler";
 import { CorrelationContextLive, MetricsServiceLive, TracingServiceLive, createSmithersRuntimeLayer, getCurrentSmithersTraceAnnotations, getCurrentSmithersTraceSpan, } from "@smithers-orchestrator/observability";
 import { toSmithersError } from "@smithers-orchestrator/errors/toSmithersError";
+import { SmithersLoggerLayer } from "./util/logger.ts";
 const ObservabilityLayer = Layer.mergeAll(CorrelationContextLive, MetricsServiceLive, TracingServiceLive);
 const SmithersCoreLayer = Layer.mergeAll(ObservabilityLayer, SchedulerLive.pipe(Layer.provide(ObservabilityLayer)), WorkflowSessionLive);
 const SmithersWorkflowEngineLayer = Layer.suspend(() => WorkflowEngine.layerMemory);
-const SmithersRuntimeLayer = Layer.mergeAll(SmithersCoreLayer, SmithersWorkflowEngineLayer, createSmithersRuntimeLayer()).pipe(Layer.orDie);
+const SmithersRuntimeLayer = Layer.mergeAll(SmithersLoggerLayer, SmithersCoreLayer, SmithersWorkflowEngineLayer, createSmithersRuntimeLayer()).pipe(Layer.orDie);
 const runtime = ManagedRuntime.make(SmithersRuntimeLayer);
 /**
  * @template A, E, R

package/src/util/logger.ts

@@ -0,0 +1,97 @@
+import { format } from "node:util";
+import { Logger } from "effect";
+
+type JsonModeState = {
+  jsonMode: boolean;
+  consoleRoutingInstalled: boolean;
+  originalConsole?: {
+    debug: typeof console.debug;
+    error: typeof console.error;
+    info: typeof console.info;
+    log: typeof console.log;
+    trace: typeof console.trace;
+    warn: typeof console.warn;
+  };
+};
+
+const STATE_KEY = Symbol.for("smithers.cli.jsonMode");
+
+function getState(): JsonModeState {
+  const globalState = globalThis as typeof globalThis & {
+    [STATE_KEY]?: JsonModeState;
+  };
+  globalState[STATE_KEY] ??= {
+    jsonMode: false,
+    consoleRoutingInstalled: false,
+  };
+  return globalState[STATE_KEY];
+}
+
+export function setJsonMode(enabled: boolean): void {
+  getState().jsonMode = enabled;
+}
+
+export function isJsonMode(): boolean {
+  return getState().jsonMode === true;
+}
+
+function writeConsoleArgsToStderr(args: ReadonlyArray<unknown>): void {
+  process.stderr.write(`${format(...args)}\n`);
+}
+
+export function installJsonModeConsoleRouting(): void {
+  const state = getState();
+  if (state.consoleRoutingInstalled) {
+    return;
+  }
+
+  const originalConsole = {
+    debug: console.debug.bind(console),
+    error: console.error.bind(console),
+    info: console.info.bind(console),
+    log: console.log.bind(console),
+    trace: console.trace.bind(console),
+    warn: console.warn.bind(console),
+  };
+
+  console.debug = (...args: unknown[]) => {
+    if (isJsonMode()) return writeConsoleArgsToStderr(args);
+    return originalConsole.debug(...args);
+  };
+  console.error = (...args: unknown[]) => {
+    if (isJsonMode()) return writeConsoleArgsToStderr(args);
+    return originalConsole.error(...args);
+  };
+  console.info = (...args: unknown[]) => {
+    if (isJsonMode()) return writeConsoleArgsToStderr(args);
+    return originalConsole.info(...args);
+  };
+  console.log = (...args: unknown[]) => {
+    if (isJsonMode()) return writeConsoleArgsToStderr(args);
+    return originalConsole.log(...args);
+  };
+  console.trace = (...args: unknown[]) => {
+    if (isJsonMode()) return writeConsoleArgsToStderr(args);
+    return originalConsole.trace(...args);
+  };
+  console.warn = (...args: unknown[]) => {
+    if (isJsonMode()) return writeConsoleArgsToStderr(args);
+    return originalConsole.warn(...args);
+  };
+
+  state.originalConsole = originalConsole;
+  state.consoleRoutingInstalled = true;
+}
+
+export const smithersEffectLogger = Logger.make<unknown, void>((options) => {
+  const line = Logger.stringLogger.log(options);
+  const stream = isJsonMode() ? process.stderr : process.stdout;
+  stream.write(`${line}\n`);
+});
+
+export const SmithersLoggerLayer = Logger.replace(
+  Logger.defaultLogger,
+  smithersEffectLogger,
+);
+
+installJsonModeConsoleRouting();

package/src/workflow-pack.js

@@ -4,7 +4,7 @@ import { dirname, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 import { generateAgentsTs } from "./agent-detection.js";
 /**
- * @typedef {{ force?: boolean; rootDir?: string; skipInstall?: boolean; }} InitOptions
+ * @typedef {{ force?: boolean; rootDir?: string; skipInstall?: boolean; agentsOnly?: boolean; }} InitOptions
  */
 /**
  * @typedef {{ status: "ok" | "skipped" | "failed"; reason?: string; }} InitInstallResult
@@ -15,6 +15,9 @@ import { generateAgentsTs } from "./agent-detection.js";
 /**
  * @typedef {{ command: string; description: string; }} WorkflowCta
  */
+/**
+ * @typedef {{ path: string; contents: string; preserveExisting?: boolean; }} TemplateFile
+ */
 
 /**
  * @param {string} path
@@ -78,6 +81,7 @@ const BUNDLED_VERSION_PINS = {
     reactTypes: "19.2.14",
     reactDomTypes: "19.2.3",
     mdxTypes: "2.0.13",
+    nodeTypes: "25.6.0",
 };
 /**
  * @returns {DependencyVersions}
@@ -90,6 +94,7 @@ function readDependencyVersions() {
         reactTypesVersion: resolveDependencyVersion("@types/react", BUNDLED_VERSION_PINS.reactTypes),
         reactDomTypesVersion: resolveDependencyVersion("@types/react-dom", BUNDLED_VERSION_PINS.reactDomTypes),
         mdxTypesVersion: resolveDependencyVersion("@types/mdx", BUNDLED_VERSION_PINS.mdxTypes),
+        nodeTypesVersion: resolveDependencyVersion("@types/node", BUNDLED_VERSION_PINS.nodeTypes),
     };
 }
 /**
@@ -116,6 +121,7 @@ function renderPackageJson(versions) {
             "@types/react": versions.reactTypesVersion,
             "@types/react-dom": versions.reactDomTypesVersion,
             "@types/mdx": versions.mdxTypesVersion,
+            "@types/node": versions.nodeTypesVersion,
         },
     }, null, 2) + "\n";
 }
@@ -143,6 +149,104 @@ function renderTsconfig() {
         exclude: ["./executions/**/*"],
     }, null, 2) + "\n";
 }
+/**
+ * @returns {TemplateFile[]}
+ */
+function renderAgentScaffoldFiles() {
+    return [
+        {
+            path: ".smithers/agents/claude-code.ts",
+            preserveExisting: true,
+            contents: [
+                'import { ClaudeCodeAgent as SmithersClaudeCodeAgent } from "smithers-orchestrator";',
+                "",
+                '// Built-in Claude Code CLI agent (cliEngine: "claude-code").',
+                "// Tweak `model`, `cwd`, or uncomment extra options below to match your setup.",
+                "export const ClaudeCodeAgent = new SmithersClaudeCodeAgent({",
+                '  model: "claude-opus-4-6",',
+                "  cwd: process.cwd(),",
+                '  // systemPrompt: "Add shared instructions for every Claude run.",',
+                "  // timeoutMs: 10 * 60 * 1000,",
+                "  // dangerouslySkipPermissions: true,",
+                "});",
+                "",
+            ].join("\n"),
+        },
+        {
+            path: ".smithers/agents/codex.ts",
+            preserveExisting: true,
+            contents: [
+                'import { CodexAgent as SmithersCodexAgent } from "smithers-orchestrator";',
+                "",
+                '// Built-in Codex CLI agent (cliEngine: "codex").',
+                "// Tweak `model`, `cwd`, or uncomment extra options below to match your setup.",
+                "export const CodexAgent = new SmithersCodexAgent({",
+                '  model: "gpt-5.3-codex",',
+                "  cwd: process.cwd(),",
+                "  skipGitRepoCheck: true,",
+                '  // systemPrompt: "Add shared instructions for every Codex run.",',
+                '  // sandbox: "workspace-write",',
+                "  // fullAuto: true,",
+                "});",
+                "",
+            ].join("\n"),
+        },
+        {
+            path: ".smithers/agents/gemini.ts",
+            preserveExisting: true,
+            contents: [
+                'import { GeminiAgent as SmithersGeminiAgent } from "smithers-orchestrator";',
+                "",
+                '// Built-in Gemini CLI agent (cliEngine: "gemini").',
+                "// Tweak `model`, `cwd`, or uncomment extra options below to match your setup.",
+                "export const GeminiAgent = new SmithersGeminiAgent({",
+                '  model: "gemini-3.1-pro-preview",',
+                "  cwd: process.cwd(),",
+                '  // systemPrompt: "Add shared instructions for every Gemini run.",',
+                '  // approvalMode: "yolo",',
+                '  // allowedTools: ["read_file", "write_file"],',
+                "});",
+                "",
+            ].join("\n"),
+        },
+        {
+            path: ".smithers/agents/index.ts",
+            preserveExisting: true,
+            contents: [
+                'export { ClaudeCodeAgent } from "./claude-code";',
+                'export { CodexAgent } from "./codex";',
+                'export { GeminiAgent } from "./gemini";',
+                "",
+            ].join("\n"),
+        },
+        {
+            path: ".smithers/agents/README.md",
+            preserveExisting: true,
+            contents: [
+                "# Agent Config",
+                "",
+                "These files export the configured agent instances used by your Smithers workflows.",
+                "",
+                "- `claude-code.ts`, `codex.ts`, and `gemini.ts` are user-owned config.",
+                "- Edit them to pin models, set `cwd`, add a shared `systemPrompt`, or enable engine-specific flags.",
+                "- `index.ts` re-exports all three so root-level files can import from `./agents`.",
+                "",
+                "Examples:",
+                "",
+                "```ts",
+                'import { ClaudeCodeAgent } from "./agents";',
+                'import { CodexAgent } from "./agents/codex";',
+                "```",
+                "",
+                "Inside `.smithers/workflows/*`, use `../agents` or `../agents/<name>` instead.",
+                "",
+                "`smithers init` and `smithers init --agents-only` only create missing files in this directory.",
+                "Existing files here are left alone so your custom agent config is preserved.",
+                "",
+            ].join("\n"),
+        },
+    ];
+}
 /**
  * @returns {TemplateFile[]}
  */
@@ -2046,6 +2150,21 @@ function renderTemplateFiles(versions, env) {
             path: ".smithers/tsconfig.json",
             contents: renderTsconfig(),
         },
+        {
+            path: ".smithers/types/assets.d.ts",
+            contents: [
+                'declare module "*.md" {',
+                "  const Component: any;",
+                "  export default Component;",
+                "}",
+                "",
+                'declare module "*.mdx" {',
+                "  const Component: any;",
+                "  export default Component;",
+                "}",
+                "",
+            ].join("\n"),
+        },
         {
             path: ".smithers/bunfig.toml",
             contents: ['preload = ["./preload.ts"]', ""].join("\n"),
@@ -2054,6 +2173,7 @@ function renderTemplateFiles(versions, env) {
             path: ".smithers/preload.ts",
             contents: ['import { mdxPlugin } from "smithers-orchestrator";', "", "mdxPlugin();", ""].join("\n"),
         },
+        ...renderAgentScaffoldFiles(),
         {
             path: ".smithers/agents.ts",
             contents: generateAgentsTs(env),
@@ -2085,35 +2205,50 @@ function renderTemplateFiles(versions, env) {
  * @returns {InitResult}
  */
 export function initWorkflowPack(options = {}) {
-    const rootDir = resolve(options.rootDir ?? process.cwd(), ".smithers");
+    const projectRoot = options.rootDir ?? process.cwd();
+    const rootDir = resolve(projectRoot, ".smithers");
     const writtenFiles = [];
     const skippedFiles = [];
     const preservedPaths = [];
-    const versions = readDependencyVersions();
-    const env = process.env;
     ensureDir(rootDir);
-    ensureDir(resolve(rootDir, "prompts"));
-    ensureDir(resolve(rootDir, "components"));
-    ensureDir(resolve(rootDir, "workflows"));
-    ensureDir(resolve(rootDir, "tickets"));
-    const executionsDir = resolve(rootDir, "executions");
-    if (existsSync(executionsDir)) {
-        preservedPaths.push(executionsDir);
+    ensureDir(resolve(rootDir, "agents"));
+    /** @type {TemplateFile[]} */
+    let templateFiles;
+    if (options.agentsOnly) {
+        templateFiles = renderAgentScaffoldFiles();
     }
     else {
-        ensureDir(executionsDir);
+        const versions = readDependencyVersions();
+        const env = process.env;
+        ensureDir(resolve(rootDir, "prompts"));
+        ensureDir(resolve(rootDir, "components"));
+        ensureDir(resolve(rootDir, "workflows"));
+        ensureDir(resolve(rootDir, "tickets"));
+        const executionsDir = resolve(rootDir, "executions");
+        if (existsSync(executionsDir)) {
+            preservedPaths.push(executionsDir);
+        }
+        else {
+            ensureDir(executionsDir);
+        }
+        templateFiles = renderTemplateFiles(versions, env);
     }
-    for (const file of renderTemplateFiles(versions, env)) {
-        const absolutePath = resolve(options.rootDir ?? process.cwd(), file.path);
+    for (const file of templateFiles) {
+        const absolutePath = resolve(projectRoot, file.path);
         ensureParent(absolutePath);
-        if (existsSync(absolutePath) && !options.force) {
+        if (existsSync(absolutePath) && (file.preserveExisting || !options.force)) {
             skippedFiles.push(absolutePath);
+            if (file.preserveExisting) {
+                process.stderr.write(`[smithers:init] ${file.path} skipped: already exists\n`);
+            }
             continue;
         }
         writeFileSync(absolutePath, file.contents, "utf8");
         writtenFiles.push(absolutePath);
     }
-    const install = runBunInstall(rootDir, options.skipInstall ?? false);
+    const install = options.agentsOnly
+        ? { status: "skipped", reason: "agents-only" }
+        : runBunInstall(rootDir, options.skipInstall ?? false);
     return {
         rootDir,
         writtenFiles,