@otto-code/cli 0.5.0

package/dist/commands/terminal/shared.js

@@ -0,0 +1,61 @@
+import { connectToDaemon, getDaemonHost } from "../../utils/client.js";
+export async function connectTerminalClient(host) {
+    const daemonHost = getDaemonHost({ host });
+    try {
+        const client = await connectToDaemon({ host });
+        return { client, daemonHost };
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        const error = {
+            code: "DAEMON_NOT_RUNNING",
+            message: `Cannot connect to daemon at ${daemonHost}: ${message}`,
+            details: "Start the daemon with: otto daemon start",
+        };
+        throw error;
+    }
+}
+export function toTerminalCommandError(code, action, err) {
+    if (err && typeof err === "object" && "code" in err && "message" in err) {
+        return err;
+    }
+    const message = err instanceof Error ? err.message : String(err);
+    const rpcCode = typeof err === "object" && err !== null && "code" in err && typeof err.code === "string"
+        ? err.code
+        : undefined;
+    return {
+        code: rpcCode ?? code,
+        message: `Failed to ${action}: ${message}`,
+    };
+}
+export async function resolveTerminalId(client, idOrName) {
+    const payload = await client.listTerminals();
+    return resolveTerminalIdentifier(idOrName, payload.terminals);
+}
+function resolveTerminalIdentifier(idOrName, terminals) {
+    if (!idOrName || terminals.length === 0) {
+        return null;
+    }
+    const query = idOrName.toLowerCase();
+    const exactMatch = terminals.find((terminal) => terminal.id === idOrName);
+    if (exactMatch) {
+        return exactMatch.id;
+    }
+    const prefixMatches = terminals.filter((terminal) => terminal.id.toLowerCase().startsWith(query));
+    if (prefixMatches.length === 1 && prefixMatches[0]) {
+        return prefixMatches[0].id;
+    }
+    if (prefixMatches.length > 1) {
+        return null;
+    }
+    const nameMatches = terminals.filter((terminal) => terminal.name?.toLowerCase() === query);
+    if (nameMatches.length === 1 && nameMatches[0]) {
+        return nameMatches[0].id;
+    }
+    const partialNameMatches = terminals.filter((terminal) => terminal.name?.toLowerCase().includes(query));
+    if (partialNameMatches.length === 1 && partialNameMatches[0]) {
+        return partialNameMatches[0].id;
+    }
+    return null;
+}
+//# sourceMappingURL=shared.js.map

package/dist/commands/worktree/archive.d.ts

@@ -0,0 +1,20 @@
+import type { Command } from "commander";
+import { connectToDaemon } from "../../utils/client.js";
+import type { CommandOptions, SingleResult, OutputSchema } from "../../output/index.js";
+/** Result type for worktree archive command */
+export interface WorktreeArchiveResult {
+    name: string;
+    status: "archived";
+    removedAgents: string[];
+}
+/** Schema for archive command output */
+export declare const archiveSchema: OutputSchema<WorktreeArchiveResult>;
+export interface WorktreeArchiveOptions extends CommandOptions {
+    host?: string;
+}
+export type WorktreeArchiveCommandResult = SingleResult<WorktreeArchiveResult>;
+export declare function runArchiveCommand(nameArg: string, options: WorktreeArchiveOptions, _command: Command): Promise<WorktreeArchiveCommandResult>;
+export declare function runArchiveCommandWithDeps(nameArg: string, options: WorktreeArchiveOptions, deps: {
+    connectToDaemon: typeof connectToDaemon;
+}): Promise<WorktreeArchiveCommandResult>;
+//# sourceMappingURL=archive.d.ts.map

package/dist/commands/worktree/archive.js

@@ -0,0 +1,104 @@
+import path from "path";
+import { connectToDaemon, getDaemonHost } from "../../utils/client.js";
+/** Schema for archive command output */
+export const archiveSchema = {
+    idField: "name",
+    columns: [
+        { header: "NAME", field: "name" },
+        { header: "STATUS", field: "status" },
+        {
+            header: "REMOVED AGENTS",
+            field: (item) => (item.removedAgents.length > 0 ? item.removedAgents.join(", ") : "-"),
+        },
+    ],
+};
+export async function runArchiveCommand(nameArg, options, _command) {
+    return runArchiveCommandWithDeps(nameArg, options, { connectToDaemon });
+}
+export async function runArchiveCommandWithDeps(nameArg, options, deps) {
+    const host = getDaemonHost({ host: options.host });
+    // Validate arguments
+    if (!nameArg || nameArg.trim().length === 0) {
+        const error = {
+            code: "MISSING_WORKTREE_NAME",
+            message: "Worktree name is required",
+            details: "Usage: otto worktree archive <name>",
+        };
+        throw error;
+    }
+    let client;
+    try {
+        client = await deps.connectToDaemon({ host: options.host });
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        const error = {
+            code: "DAEMON_NOT_RUNNING",
+            message: `Cannot connect to daemon at ${host}: ${message}`,
+            details: "Start the daemon with: otto daemon start",
+        };
+        throw error;
+    }
+    try {
+        // Get the list of worktrees first to resolve the name
+        const listResponse = await client.getOttoWorktreeList({});
+        if (listResponse.error) {
+            const error = {
+                code: "WORKTREE_LIST_FAILED",
+                message: `Failed to list worktrees: ${listResponse.error.message}`,
+            };
+            throw error;
+        }
+        // Find the worktree by name or branch
+        const worktree = listResponse.worktrees.find((wt) => {
+            const name = path.basename(wt.worktreePath);
+            return name === nameArg || wt.branchName === nameArg;
+        });
+        if (!worktree) {
+            const error = {
+                code: "WORKTREE_NOT_FOUND",
+                message: `Worktree not found: ${nameArg}`,
+                details: 'Use "otto worktree ls" to list available worktrees',
+            };
+            throw error;
+        }
+        // Archive the worktree. scope:"worktree" archives every active workspace on
+        // the directory and then removes the directory (Otto-owned gated).
+        const response = await client.archiveOttoWorktree({
+            worktreePath: worktree.worktreePath,
+            scope: "worktree",
+        });
+        await client.close();
+        if (response.error) {
+            const error = {
+                code: "WORKTREE_ARCHIVE_FAILED",
+                message: `Failed to archive worktree: ${response.error.message}`,
+            };
+            throw error;
+        }
+        const worktreeName = path.basename(worktree.worktreePath) || nameArg;
+        return {
+            type: "single",
+            data: {
+                name: worktreeName,
+                status: "archived",
+                removedAgents: response.removedAgents ?? [],
+            },
+            schema: archiveSchema,
+        };
+    }
+    catch (err) {
+        await client.close().catch(() => { });
+        // Re-throw CommandError as-is
+        if (err && typeof err === "object" && "code" in err) {
+            throw err;
+        }
+        const message = err instanceof Error ? err.message : String(err);
+        const error = {
+            code: "WORKTREE_ARCHIVE_FAILED",
+            message: `Failed to archive worktree: ${message}`,
+        };
+        throw error;
+    }
+}
+//# sourceMappingURL=archive.js.map

package/dist/commands/worktree/create-input.d.ts

@@ -0,0 +1,15 @@
+import type { DaemonClient } from "@otto-code/client/internal/daemon-client";
+import type { CommandOptions } from "../../output/index.js";
+export interface WorktreeCreateOptions extends CommandOptions {
+    host?: string;
+    cwd?: string;
+    mode?: string;
+    newBranch?: string;
+    base?: string;
+    branch?: string;
+    prNumber?: string;
+}
+type CreateOttoWorktreeRequest = Parameters<DaemonClient["createOttoWorktree"]>[0];
+export declare function buildCreateWorktreeRequest(options: WorktreeCreateOptions, cwd: string): CreateOttoWorktreeRequest;
+export {};
+//# sourceMappingURL=create-input.d.ts.map

package/dist/commands/worktree/create-input.js

@@ -0,0 +1,56 @@
+const VALID_MODES = ["branch-off", "checkout-branch", "checkout-pr"];
+export function buildCreateWorktreeRequest(options, cwd) {
+    const mode = options.mode;
+    if (!mode) {
+        throw cmdError("MISSING_MODE", "--mode is required", `Expected one of: ${VALID_MODES.join(", ")}`);
+    }
+    switch (mode) {
+        case "branch-off":
+            return buildBranchOffRequest(options, cwd);
+        case "checkout-branch":
+            return buildCheckoutBranchRequest(options, cwd);
+        case "checkout-pr":
+            return buildCheckoutPrRequest(options, cwd);
+        default:
+            throw cmdError("INVALID_MODE", `Invalid --mode: ${mode}`, `Expected one of: ${VALID_MODES.join(", ")}`);
+    }
+}
+function buildBranchOffRequest(options, cwd) {
+    if (!options.newBranch) {
+        throw cmdError("MISSING_NEW_BRANCH", "--new-branch is required for --mode branch-off");
+    }
+    return {
+        cwd,
+        worktreeSlug: options.newBranch,
+        action: "branch-off",
+        ...(options.base ? { refName: options.base } : {}),
+    };
+}
+function buildCheckoutBranchRequest(options, cwd) {
+    if (!options.branch) {
+        throw cmdError("MISSING_BRANCH", "--branch is required for --mode checkout-branch");
+    }
+    return {
+        cwd,
+        action: "checkout",
+        refName: options.branch,
+    };
+}
+function buildCheckoutPrRequest(options, cwd) {
+    if (options.prNumber === undefined || options.prNumber === "") {
+        throw cmdError("MISSING_PR_NUMBER", "--pr-number is required for --mode checkout-pr");
+    }
+    const prNumber = Number(options.prNumber);
+    if (!Number.isInteger(prNumber) || prNumber <= 0) {
+        throw cmdError("INVALID_PR_NUMBER", `Invalid --pr-number: ${options.prNumber}`, "Expected a positive integer");
+    }
+    return {
+        cwd,
+        action: "checkout",
+        githubPrNumber: prNumber,
+    };
+}
+function cmdError(code, message, details) {
+    return details ? { code, message, details } : { code, message };
+}
+//# sourceMappingURL=create-input.js.map

package/dist/commands/worktree/create.d.ts

@@ -0,0 +1,11 @@
+import type { Command } from "commander";
+import type { OutputSchema, SingleResult } from "../../output/index.js";
+import { type WorktreeCreateOptions } from "./create-input.js";
+export interface WorktreeCreateResult {
+    name: string;
+    branchName: string;
+    worktreePath: string;
+}
+export declare const createSchema: OutputSchema<WorktreeCreateResult>;
+export declare function runCreateCommand(options: WorktreeCreateOptions, _command: Command): Promise<SingleResult<WorktreeCreateResult>>;
+//# sourceMappingURL=create.d.ts.map

package/dist/commands/worktree/create.js

@@ -0,0 +1,58 @@
+import path from "node:path";
+import { connectToDaemon, getDaemonHost } from "../../utils/client.js";
+import { buildCreateWorktreeRequest } from "./create-input.js";
+export const createSchema = {
+    idField: "worktreePath",
+    columns: [
+        { header: "NAME", field: "name", width: 24 },
+        { header: "BRANCH", field: "branchName", width: 28 },
+        { header: "PATH", field: "worktreePath", width: 50 },
+    ],
+};
+function cmdError(code, message, details) {
+    return details ? { code, message, details } : { code, message };
+}
+export async function runCreateCommand(options, _command) {
+    const cwd = options.cwd ?? process.cwd();
+    const request = buildCreateWorktreeRequest(options, cwd);
+    const host = getDaemonHost({ host: options.host });
+    let client;
+    try {
+        client = await connectToDaemon({ host: options.host });
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        throw cmdError("DAEMON_NOT_RUNNING", `Cannot connect to daemon at ${host}: ${message}`, "Start the daemon with: otto daemon start");
+    }
+    try {
+        const response = await client.createOttoWorktree(request);
+        const workspace = response.workspace;
+        if (!workspace || response.error) {
+            throw cmdError("WORKTREE_CREATE_FAILED", `Failed to create worktree: ${response.error ?? "no workspace returned"}`);
+        }
+        if (!workspace.workspaceDirectory) {
+            throw cmdError("WORKTREE_CREATE_FAILED", "Failed to create worktree: workspace directory missing from daemon response");
+        }
+        const worktreePath = workspace.workspaceDirectory;
+        return {
+            type: "single",
+            data: {
+                name: path.basename(worktreePath),
+                branchName: workspace.name,
+                worktreePath,
+            },
+            schema: createSchema,
+        };
+    }
+    catch (err) {
+        if (err && typeof err === "object" && "code" in err) {
+            throw err;
+        }
+        const message = err instanceof Error ? err.message : String(err);
+        throw cmdError("WORKTREE_CREATE_FAILED", `Failed to create worktree: ${message}`);
+    }
+    finally {
+        await client.close().catch(() => { });
+    }
+}
+//# sourceMappingURL=create.js.map

package/dist/commands/worktree/index.d.ts

@@ -0,0 +1,3 @@
+import { Command } from "commander";
+export declare function createWorktreeCommand(): Command;
+//# sourceMappingURL=index.d.ts.map

package/dist/commands/worktree/index.js

@@ -0,0 +1,25 @@
+import { Command } from "commander";
+import { runLsCommand } from "./ls.js";
+import { runArchiveCommand } from "./archive.js";
+import { runCreateCommand } from "./create.js";
+import { withOutput } from "../../output/index.js";
+import { addJsonAndDaemonHostOptions } from "../../utils/command-options.js";
+export function createWorktreeCommand() {
+    const worktree = new Command("worktree").description("Manage Otto-managed git worktrees");
+    addJsonAndDaemonHostOptions(worktree.command("ls").description("List Otto-managed git worktrees")).action(withOutput(runLsCommand));
+    addJsonAndDaemonHostOptions(worktree
+        .command("create")
+        .description("Create a Otto-managed git worktree")
+        .option("--mode <mode>", "Creation mode: branch-off, checkout-branch, or checkout-pr")
+        .option("--new-branch <name>", "New branch name (--mode branch-off)")
+        .option("--base <ref>", "Base ref for new branch (--mode branch-off, defaults to repo default)")
+        .option("--branch <name>", "Existing branch to check out (--mode checkout-branch)")
+        .option("--pr-number <n>", "Pull request number (--mode checkout-pr)")
+        .option("--cwd <path>", "Repository directory (default: current)")).action(withOutput(runCreateCommand));
+    addJsonAndDaemonHostOptions(worktree
+        .command("archive")
+        .description("Archive a worktree (removes worktree and associated branch)")
+        .argument("<name>", "Worktree name or branch name")).action(withOutput(runArchiveCommand));
+    return worktree;
+}
+//# sourceMappingURL=index.js.map

package/dist/commands/worktree/ls.d.ts

@@ -0,0 +1,19 @@
+import type { Command } from "commander";
+import type { CommandOptions, ListResult, OutputSchema } from "../../output/index.js";
+/** Worktree list item for display */
+export interface WorktreeListItem {
+    name: string;
+    branch: string;
+    cwd: string;
+    agent: string;
+}
+export declare function resolveOttoHomePath(): string;
+export declare function resolveOttoWorktreesDir(): string;
+/** Schema for worktree ls output */
+export declare const worktreeLsSchema: OutputSchema<WorktreeListItem>;
+export type WorktreeLsResult = ListResult<WorktreeListItem>;
+export interface WorktreeLsOptions extends CommandOptions {
+    host?: string;
+}
+export declare function runLsCommand(options: WorktreeLsOptions, _command: Command): Promise<WorktreeLsResult>;
+//# sourceMappingURL=ls.d.ts.map

package/dist/commands/worktree/ls.js

@@ -0,0 +1,97 @@
+import { homedir } from "node:os";
+import { basename, join, sep } from "node:path";
+import { connectToDaemon, getDaemonHost } from "../../utils/client.js";
+/** Shorten home directory in path */
+function shortenPath(path) {
+    const home = process.env.HOME;
+    if (home && path.startsWith(home)) {
+        return "~" + path.slice(home.length);
+    }
+    return path;
+}
+/** Extract worktree name from path */
+function extractWorktreeName(path) {
+    return basename(path);
+}
+export function resolveOttoHomePath() {
+    return process.env.OTTO_HOME ?? join(homedir(), ".otto");
+}
+export function resolveOttoWorktreesDir() {
+    return join(resolveOttoHomePath(), "worktrees");
+}
+function isAgentInManagedWorktree(agentCwd) {
+    const worktreesDir = resolveOttoWorktreesDir();
+    return agentCwd === worktreesDir || agentCwd.startsWith(worktreesDir + sep);
+}
+/** Schema for worktree ls output */
+export const worktreeLsSchema = {
+    idField: "name",
+    columns: [
+        { header: "NAME", field: "name", width: 20 },
+        { header: "BRANCH", field: "branch", width: 25 },
+        { header: "CWD", field: "cwd", width: 45 },
+        { header: "AGENT", field: "agent", width: 10 },
+    ],
+};
+export async function runLsCommand(options, _command) {
+    const host = getDaemonHost({ host: options.host });
+    let client;
+    try {
+        client = await connectToDaemon({ host: options.host });
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        const error = {
+            code: "DAEMON_NOT_RUNNING",
+            message: `Cannot connect to daemon at ${host}: ${message}`,
+            details: "Start the daemon with: otto daemon start",
+        };
+        throw error;
+    }
+    try {
+        const agentsPayload = await client.fetchAgents({ filter: { includeArchived: true } });
+        const agents = agentsPayload.entries.map((entry) => entry.agent);
+        // Get worktree list from daemon
+        const response = await client.getOttoWorktreeList({});
+        await client.close();
+        if (response.error) {
+            const error = {
+                code: "WORKTREE_LIST_FAILED",
+                message: `Failed to list worktrees: ${response.error.message}`,
+            };
+            throw error;
+        }
+        // Build a map of worktree paths to agent IDs
+        const worktreeAgentMap = new Map();
+        for (const agent of agents) {
+            if (isAgentInManagedWorktree(agent.cwd)) {
+                worktreeAgentMap.set(agent.cwd, agent.id.slice(0, 7));
+            }
+        }
+        const items = response.worktrees.map((wt) => ({
+            name: extractWorktreeName(wt.worktreePath),
+            branch: wt.branchName ?? "-",
+            cwd: shortenPath(wt.worktreePath),
+            agent: worktreeAgentMap.get(wt.worktreePath) ?? "-",
+        }));
+        return {
+            type: "list",
+            data: items,
+            schema: worktreeLsSchema,
+        };
+    }
+    catch (err) {
+        await client.close().catch(() => { });
+        // Re-throw CommandError as-is
+        if (err && typeof err === "object" && "code" in err) {
+            throw err;
+        }
+        const message = err instanceof Error ? err.message : String(err);
+        const error = {
+            code: "WORKTREE_LIST_FAILED",
+            message: `Failed to list worktrees: ${message}`,
+        };
+        throw error;
+    }
+}
+//# sourceMappingURL=ls.js.map

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -0,0 +1,6 @@
+import { runCli } from "./run.js";
+const exitCode = await runCli(process.argv.slice(2), {
+    nodeArgv: [process.argv[0] ?? "node", process.argv[1] ?? "otto"],
+});
+process.exitCode = exitCode;
+//# sourceMappingURL=index.js.map

package/dist/output/index.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Output abstraction layer for the Otto CLI.
+ *
+ * This module provides structured output rendering with support for multiple formats:
+ * - table: Human-readable aligned tables (default)
+ * - json: Machine-readable JSON
+ * - yaml: Machine-readable YAML
+ * - quiet: Minimal output (IDs only)
+ *
+ * @example
+ * ```typescript
+ * import { withOutput, render, type ListResult, type OutputSchema } from './output/index.js'
+ *
+ * // Define your data type
+ * interface Agent { id: string; title: string; status: string }
+ *
+ * // Define how to render it
+ * const schema: OutputSchema<Agent> = {
+ *   idField: 'id',
+ *   columns: [
+ *     { header: 'ID', field: 'id' },
+ *     { header: 'TITLE', field: 'title' },
+ *     { header: 'STATUS', field: 'status', color: (v) => v === 'running' ? 'green' : undefined },
+ *   ],
+ * }
+ *
+ * // Return structured data from commands
+ * const result: ListResult<Agent> = {
+ *   type: 'list',
+ *   data: agents,
+ *   schema,
+ * }
+ *
+ * // Render with options
+ * const output = render(result, { format: 'json' })
+ * ```
+ */
+export type { OutputFormat, OutputOptions, ColumnDef, OutputSchema, CommandResult, SingleResult, ListResult, AnyCommandResult, CommandError, } from "./types.js";
+export { renderTable, renderTableHeader, renderTableRow } from "./table.js";
+export { renderJson, renderJsonLine } from "./json.js";
+export { renderYaml, renderYamlDoc } from "./yaml.js";
+export { renderQuiet } from "./quiet.js";
+export { render, renderError, toCommandError, defaultOutputOptions } from "./render.js";
+export { withOutput, createOutputOptions, type CommandOptions } from "./with-output.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/output/index.js

@@ -0,0 +1,47 @@
+/**
+ * Output abstraction layer for the Otto CLI.
+ *
+ * This module provides structured output rendering with support for multiple formats:
+ * - table: Human-readable aligned tables (default)
+ * - json: Machine-readable JSON
+ * - yaml: Machine-readable YAML
+ * - quiet: Minimal output (IDs only)
+ *
+ * @example
+ * ```typescript
+ * import { withOutput, render, type ListResult, type OutputSchema } from './output/index.js'
+ *
+ * // Define your data type
+ * interface Agent { id: string; title: string; status: string }
+ *
+ * // Define how to render it
+ * const schema: OutputSchema<Agent> = {
+ *   idField: 'id',
+ *   columns: [
+ *     { header: 'ID', field: 'id' },
+ *     { header: 'TITLE', field: 'title' },
+ *     { header: 'STATUS', field: 'status', color: (v) => v === 'running' ? 'green' : undefined },
+ *   ],
+ * }
+ *
+ * // Return structured data from commands
+ * const result: ListResult<Agent> = {
+ *   type: 'list',
+ *   data: agents,
+ *   schema,
+ * }
+ *
+ * // Render with options
+ * const output = render(result, { format: 'json' })
+ * ```
+ */
+// Renderers
+export { renderTable, renderTableHeader, renderTableRow } from "./table.js";
+export { renderJson, renderJsonLine } from "./json.js";
+export { renderYaml, renderYamlDoc } from "./yaml.js";
+export { renderQuiet } from "./quiet.js";
+// Main render function
+export { render, renderError, toCommandError, defaultOutputOptions } from "./render.js";
+// Command wrapper
+export { withOutput, createOutputOptions } from "./with-output.js";
+//# sourceMappingURL=index.js.map

package/dist/output/json.d.ts

@@ -0,0 +1,11 @@
+/**
+ * JSON renderer for CLI output.
+ *
+ * Renders structured data as formatted JSON for machine consumption.
+ */
+import type { AnyCommandResult, OutputOptions } from "./types.js";
+/** Render command result as JSON */
+export declare function renderJson<T>(result: AnyCommandResult<T>, _options: OutputOptions): string;
+/** Render a single item as JSON line (for NDJSON streaming) */
+export declare function renderJsonLine<T>(item: T, serialize?: (data: T) => unknown): string;
+//# sourceMappingURL=json.d.ts.map

package/dist/output/json.js

@@ -0,0 +1,37 @@
+/**
+ * JSON renderer for CLI output.
+ *
+ * Renders structured data as formatted JSON for machine consumption.
+ */
+/** Render command result as JSON */
+export function renderJson(result, _options) {
+    const { schema } = result;
+    // Apply custom serializer if provided
+    if (schema.serialize) {
+        if (result.type === "list") {
+            // If all items serialize to the same object, return just one
+            // This handles the case where a list of key-value rows should serialize
+            // to a single structured object
+            const serialized = result.data.map((item) => schema.serialize(item));
+            if (serialized.length > 0) {
+                const first = JSON.stringify(serialized[0]);
+                const allSame = serialized.every((s) => JSON.stringify(s) === first);
+                if (allSame) {
+                    return JSON.stringify(serialized[0], null, 2);
+                }
+            }
+            return JSON.stringify(serialized, null, 2);
+        }
+        else {
+            const serialized = schema.serialize(result.data);
+            return JSON.stringify(serialized, null, 2);
+        }
+    }
+    return JSON.stringify(result.data, null, 2);
+}
+/** Render a single item as JSON line (for NDJSON streaming) */
+export function renderJsonLine(item, serialize) {
+    const output = serialize ? serialize(item) : item;
+    return JSON.stringify(output);
+}
+//# sourceMappingURL=json.js.map

package/dist/output/quiet.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Quiet renderer for CLI output.
+ *
+ * Outputs only ID fields, one per line. Useful for scripting and pipelines.
+ */
+import type { AnyCommandResult, OutputOptions } from "./types.js";
+/** Render command result in quiet mode (IDs only) */
+export declare function renderQuiet<T>(result: AnyCommandResult<T>, _options: OutputOptions): string;
+//# sourceMappingURL=quiet.d.ts.map

package/dist/output/quiet.js

@@ -0,0 +1,22 @@
+/**
+ * Quiet renderer for CLI output.
+ *
+ * Outputs only ID fields, one per line. Useful for scripting and pipelines.
+ */
+/** Extract ID from item using schema definition */
+function getId(item, idField) {
+    if (typeof idField === "function") {
+        return idField(item);
+    }
+    return String(item[idField]);
+}
+/** Render command result in quiet mode (IDs only) */
+export function renderQuiet(result, _options) {
+    if (result.type === "single") {
+        return getId(result.data, result.schema.idField);
+    }
+    else {
+        return result.data.map((item) => getId(item, result.schema.idField)).join("\n");
+    }
+}
+//# sourceMappingURL=quiet.js.map