toolcraft 0.0.136 → 0.0.138

package/node_modules/@poe-code/agent-defs/dist/capabilities.js

@@ -0,0 +1,63 @@
+import { allAgents, resolveAgentId } from "./registry.js";
+export function listAgentsWithCapability(capability, options) {
+    const names = [];
+    for (const agent of allAgents) {
+        if (!agent.capabilities?.includes(capability)) {
+            continue;
+        }
+        names.push(agent.id);
+        if (options?.includeAliases) {
+            names.push(...(agent.aliases ?? []));
+        }
+    }
+    return names;
+}
+export function agentSupportsCapability(input, capability) {
+    const id = resolveAgentId(input);
+    return id !== undefined && listAgentsWithCapability(capability).includes(id);
+}
+const MAX_SUGGESTION_DISTANCE = 3;
+function editDistance(a, b) {
+    let previous = Array.from({ length: b.length + 1 }, (_unused, index) => index);
+    for (let i = 1; i <= a.length; i += 1) {
+        const current = [i];
+        for (let j = 1; j <= b.length; j += 1) {
+            const substitution = previous[j - 1] + (a[i - 1] === b[j - 1] ? 0 : 1);
+            current[j] = Math.min(substitution, previous[j] + 1, current[j - 1] + 1);
+        }
+        previous = current;
+    }
+    return previous[b.length];
+}
+/** Every candidate tied for the smallest edit distance, when one is close enough. */
+function suggest(input, candidates) {
+    const needle = input.trim().toLowerCase();
+    const scored = candidates
+        .map((candidate) => ({ candidate, score: editDistance(needle, candidate.toLowerCase()) }))
+        .filter((entry) => entry.score <= MAX_SUGGESTION_DISTANCE);
+    if (scored.length === 0) {
+        return [];
+    }
+    const best = Math.min(...scored.map((entry) => entry.score));
+    return scored.filter((entry) => entry.score === best).map((entry) => entry.candidate);
+}
+/**
+ * The single message for every agent argument that misses. It distinguishes a
+ * typo (unknown id, plus a did-you-mean) from a real capability gap ("pi
+ * supports: spawn"), and always names the agents the command does accept.
+ */
+export function formatAgentCapabilityError(input) {
+    const allowed = listAgentsWithCapability(input.capability, { includeAliases: true });
+    const allowList = `Agents supporting ${input.capability}: ${allowed.length > 0 ? allowed.join(", ") : "none"}.`;
+    const id = resolveAgentId(input.agent);
+    if (!id) {
+        const near = suggest(input.agent, allowed);
+        const hint = near.length > 0 ? ` Did you mean: ${near.join(", ")}?` : "";
+        return `Unknown agent "${input.agent}".${hint} ${allowList}`;
+    }
+    const supported = ["spawn", "configure", "install", "test", "skill", "mcp"].filter((capability) => listAgentsWithCapability(capability).includes(id));
+    const supports = supported.length > 0
+        ? `${id} supports: ${supported.join(", ")}.`
+        : `${id} is not supported by poe-code agent commands.`;
+    return `Agent "${id}" does not support ${input.capability}. ${supports} ${allowList}`;
+}

package/node_modules/@poe-code/agent-defs/dist/index.d.ts

@@ -1,5 +1,6 @@
-export type { AgentDefinition, ApiShapeId, OtelCaptureDefinition } from "./types.js";
+export type { AgentCapability, AgentDefinition, ApiShapeId, OtelCaptureDefinition } from "./types.js";
 export type { AgentSpecifier } from "./specifier.js";
 export { claudeCodeAgent, claudeDesktopAgent, codexAgent, cursorAgent, geminiCliAgent, openCodeAgent, kimiAgent, gooseAgent, piAgent, poeAgentAgent } from "./agents/index.js";
 export { allAgents, resolveAgentId } from "./registry.js";
+export { agentSupportsCapability, formatAgentCapabilityError, listAgentsWithCapability } from "./capabilities.js";
 export { parseAgentSpecifier, formatAgentSpecifier, normalizeAgentId } from "./specifier.js";

package/node_modules/@poe-code/agent-defs/dist/index.js

@@ -1,3 +1,4 @@
 export { claudeCodeAgent, claudeDesktopAgent, codexAgent, cursorAgent, geminiCliAgent, openCodeAgent, kimiAgent, gooseAgent, piAgent, poeAgentAgent } from "./agents/index.js";
 export { allAgents, resolveAgentId } from "./registry.js";
+export { agentSupportsCapability, formatAgentCapabilityError, listAgentsWithCapability } from "./capabilities.js";
 export { parseAgentSpecifier, formatAgentSpecifier, normalizeAgentId } from "./specifier.js";

package/node_modules/@poe-code/agent-defs/dist/registry.js

@@ -6,6 +6,9 @@ function freezeAgent(agent) {
     if (agent.apiShapes !== undefined) {
         Object.freeze(agent.apiShapes);
     }
+    if (agent.capabilities !== undefined) {
+        Object.freeze(agent.capabilities);
+    }
     if (agent.otelCapture?.env !== undefined) {
         Object.freeze(agent.otelCapture.env);
     }

package/node_modules/@poe-code/agent-defs/dist/types.d.ts

@@ -1,4 +1,10 @@
 export type ApiShapeId = "openai-chat-completions" | "openai-responses" | "anthropic-messages" | "google-generations";
+/**
+ * The poe-code surfaces an agent can be used with. This is the single
+ * published source for each command's allow-list; `agent-capability-matrix.test.ts`
+ * pins every value to the registry that implements it, so the sets cannot drift.
+ */
+export type AgentCapability = "spawn" | "configure" | "install" | "test" | "skill" | "mcp";
 export interface OtelCaptureDefinition {
     env?: Record<string, string>;
     args?: (endpoint: string, content: boolean) => string[];
@@ -11,6 +17,7 @@ export interface AgentDefinition {
     aliases?: string[];
     /** Binary name for CLI agents. Optional for GUI-only apps like Claude Desktop. */
     binaryName?: string;
+    readonly capabilities?: readonly AgentCapability[];
     readonly apiShapes?: readonly ApiShapeId[];
     readonly otelCapture?: OtelCaptureDefinition;
     configPath?: string;

package/node_modules/@poe-code/frontmatter/README.md

@@ -6,7 +6,9 @@ Shared YAML frontmatter parsing for poe-code packages.
 
 ```ts
 import {
+  FrontmatterKindError,
   FrontmatterParseError,
+  isFrontmatterKindError,
   parseFrontmatter,
   parseFrontmatterDocument,
   stringifyFrontmatter
@@ -17,6 +19,7 @@ import {
 - `parseFrontmatterDocument(source)` returns `{ frontmatter, body, errors, lineCounter }` for callers that need YAML diagnostics.
 - `stringifyFrontmatter(frontmatter, body)` writes `---` fences, YAML, and the body.
 - `FrontmatterParseError` is thrown for malformed frontmatter, invalid YAML, non-object frontmatter, and stringify failures.
+- `FrontmatterKindError` extends `FrontmatterParseError` and carries `expectedKind` / `foundKind` so callers can report a document kind mismatch instead of a missing file. `isFrontmatterKindError(error)` narrows to it.
 
 When no leading frontmatter block exists, parsing returns `{ frontmatter: {}, body: source }`.
 The returned `body` is sliced from the original input and is otherwise byte-for-byte unchanged.

package/node_modules/@poe-code/frontmatter/dist/index.d.ts

@@ -1,3 +1,3 @@
 export { splitFrontmatterBlock, type FrontmatterBlock, type SplitFrontmatterResult } from "./fences.js";
-export { FrontmatterParseError, parseFrontmatter, parseFrontmatterDocument, type ParsedFrontmatter, type ParsedFrontmatterDocument, type ParseFrontmatterOptions } from "./parse.js";
+export { FrontmatterKindError, FrontmatterParseError, isFrontmatterKindError, parseFrontmatter, parseFrontmatterDocument, type ParsedFrontmatter, type ParsedFrontmatterDocument, type ParseFrontmatterOptions } from "./parse.js";
 export { stringifyFrontmatter } from "./stringify.js";

package/node_modules/@poe-code/frontmatter/dist/index.js

@@ -1,3 +1,3 @@
 export { splitFrontmatterBlock } from "./fences.js";
-export { FrontmatterParseError, parseFrontmatter, parseFrontmatterDocument } from "./parse.js";
+export { FrontmatterKindError, FrontmatterParseError, isFrontmatterKindError, parseFrontmatter, parseFrontmatterDocument } from "./parse.js";
 export { stringifyFrontmatter } from "./stringify.js";

package/node_modules/@poe-code/frontmatter/dist/parse.d.ts

@@ -16,5 +16,14 @@ export interface ParseFrontmatterOptions {
 export declare class FrontmatterParseError extends Error {
     constructor(message: string);
 }
+export declare class FrontmatterKindError extends FrontmatterParseError {
+    readonly expectedKind: string;
+    readonly foundKind: string;
+    constructor(message: string, kinds: {
+        expected: string;
+        found: string;
+    });
+}
+export declare function isFrontmatterKindError(error: unknown): error is FrontmatterKindError;
 export declare function parseFrontmatter(source: string, options?: ParseFrontmatterOptions): ParsedFrontmatter;
 export declare function parseFrontmatterDocument(source: string, options?: ParseFrontmatterOptions): ParsedFrontmatterDocument;

package/node_modules/@poe-code/frontmatter/dist/parse.js

@@ -6,6 +6,22 @@ export class FrontmatterParseError extends Error {
         this.name = "FrontmatterParseError";
     }
 }
+export class FrontmatterKindError extends FrontmatterParseError {
+    expectedKind;
+    foundKind;
+    constructor(message, kinds) {
+        super(message);
+        this.name = "FrontmatterKindError";
+        this.expectedKind = kinds.expected;
+        this.foundKind = kinds.found;
+    }
+}
+export function isFrontmatterKindError(error) {
+    return (error instanceof Error &&
+        error.name === "FrontmatterKindError" &&
+        typeof error.expectedKind === "string" &&
+        typeof error.foundKind === "string");
+}
 export function parseFrontmatter(source, options = {}) {
     const split = splitFrontmatter(source);
     if (split.raw === undefined) {

package/node_modules/@poe-code/process-runner/dist/docker/docker-execution-env.js

@@ -14,6 +14,7 @@ const containerCommand = ["sh", "-c", "while :; do sleep 3600; done"];
 export const dockerExecutionEnvFactory = {
     type: "docker",
     supportsDetach: true,
+    supportsWorkspaceTransfer: true,
     async open(spec) {
         const runtime = parseDockerRuntime(spec.runtime);
         const runner = spec.hostRunner ?? createHostRunner();
@@ -499,8 +500,11 @@ function createContainerJob(containerId, runner, engine, context, detachedJobCon
         argv: detachedJobContext?.argv ?? ["attach", containerId],
         async status() {
             if (detachedJobContext !== null) {
-                const exitCode = await readDetachedExitCode(containerId, jobId, runner, engine, context);
-                return exitCode === null ? "running" : "exited";
+                const detached = await readDetachedState(containerId, jobId, runner, engine, context);
+                if (detached.kind === "unreachable") {
+                    return "lost";
+                }
+                return detached.kind === "exited" ? "exited" : "running";
             }
             const handle = runner.exec({
                 command: engine,
@@ -565,9 +569,14 @@ function createContainerJob(containerId, runner, engine, context, detachedJobCon
         async wait() {
             if (detachedJobContext !== null) {
                 while (true) {
-                    const exitCode = await readDetachedExitCode(containerId, jobId, runner, engine, context);
-                    if (exitCode !== null) {
-                        return { exitCode };
+                    const detached = await readDetachedState(containerId, jobId, runner, engine, context);
+                    if (detached.kind === "exited") {
+                        return { exitCode: detached.exitCode };
+                    }
+                    if (detached.kind === "unreachable") {
+                        // The container is gone, so the command can never report its own exit
+                        // code: treat it as terminated with an unknown failure.
+                        return { exitCode: 1 };
                     }
                     await new Promise((resolve) => setTimeout(resolve, 25));
                 }
@@ -651,7 +660,7 @@ function utf8SequenceLength(byte) {
     }
     return 0;
 }
-async function readDetachedExitCode(containerId, jobId, runner, engine, context) {
+async function readDetachedState(containerId, jobId, runner, engine, context) {
     const exitFile = shellQuote(`/tmp/poe-jobs/${jobId}.exit`);
     const handle = runner.exec({
         command: engine,
@@ -669,10 +678,13 @@ async function readDetachedExitCode(containerId, jobId, runner, engine, context)
     const stdout = await readStream(handle.stdout);
     const result = await handle.result;
     if (result.exitCode !== 0) {
-        return null;
+        return { kind: "unreachable" };
     }
     const text = stdout.trim();
-    return text.length === 0 ? null : parseCompleteDecimalExitCode(text, "detached exit marker");
+    if (text.length === 0) {
+        return { kind: "running" };
+    }
+    return { kind: "exited", exitCode: parseCompleteDecimalExitCode(text, "detached exit marker") };
 }
 function createAttachedSpec(cwd = "/workspace") {
     return {

package/node_modules/@poe-code/process-runner/dist/host/host-execution-env.js

@@ -2,6 +2,7 @@ import { createHostRunner } from "./host-runner.js";
 export const hostExecutionEnvFactory = {
     type: "host",
     supportsDetach: false,
+    supportsWorkspaceTransfer: false,
     async open(openSpec) {
         return {
             id: "host",

package/node_modules/@poe-code/process-runner/dist/types.d.ts

@@ -35,6 +35,8 @@ export type JobStatus = "running" | "exited" | "killed" | "lost";
 export interface ExecutionEnvFactory {
     readonly type: ExecutionEnvType;
     readonly supportsDetach?: boolean;
+    /** Whether uploadWorkspace/downloadWorkspace move real files, i.e. whether runner.sync means anything. */
+    readonly supportsWorkspaceTransfer?: boolean;
     open(spec: OpenSpec): Promise<OpenedEnv>;
     attach(envId: string, context?: AttachedJobContext): Promise<OpenedEnv>;
 }

package/node_modules/@poe-code/task-list/dist/backends/gh-issues-client.js

@@ -1,5 +1,6 @@
 import { text } from "node:stream/consumers";
 import { createHostRunner } from "@poe-code/process-runner";
+import { UserError } from "@poe-code/user-error";
 const DEFAULT_ENDPOINT = "https://api.github.com/graphql";
 const USER_AGENT = "poe-code-task-list/0.0.1";
 const AUTH_ERROR = "gh auth token failed; install gh, run 'gh auth login', or pass auth: { token }";
@@ -18,6 +19,9 @@ export function createGhClient(options) {
                 body: JSON.stringify({ query, variables })
             });
             const body = await response.text();
+            if (response.status === 401) {
+                throw new UserError("GitHub rejected your credentials (HTTP 401). Your token is missing or expired - run 'gh auth login', or pass a valid token via auth: { token }.");
+            }
             if (response.status !== 200) {
                 throw new Error(`GitHub GraphQL request failed with status ${response.status}: ${body}`);
             }

package/node_modules/@poe-code/user-error/README.md

@@ -0,0 +1,56 @@
+# @poe-code/user-error
+
+The shared user-error type every workspace package throws for expected user
+mistakes, and the guard the CLI renders them with.
+
+`src/cli/errors.ts` cannot be imported from `packages/*`, so package code used to
+throw a plain `Error` for recoverable conditions. `src/cli/bootstrap.ts` then
+treated each one as a crash: an `Error:` prefix plus a `See logs at
+~/.poe-code/logs/errors.log` pointer to a log that adds nothing for a typo. This
+package gives packages a classification the CLI honours.
+
+## Usage
+
+```ts
+import { UserError, isUserError } from "@poe-code/user-error";
+
+throw new UserError('Unknown agent "clyde". Try: claude, codex, gemini.');
+
+throw new UserError("No API key found.", {
+  hint: "Create one at https://poe.com/api_key",
+  cause: readError
+});
+
+if (isUserError(error)) {
+  // render the message as guidance: no stack trace, no log pointer
+}
+```
+
+Throw a `UserError` when the user can fix the condition themselves, and say how:
+name the value that was rejected and the valid ones, the path that was searched,
+or the URL that issues the key. Keep plain `Error` for genuine failures — those
+should reach the log.
+
+## Public API
+
+- `UserError`: `Error` subclass with `name === "UserError"` and an optional
+  `hint` for the recovery step. Accepts the standard `cause` option.
+- `isUserError(error)`: true for a `UserError` **or** any `Error` whose `name` is
+  `"UserError"`.
+
+## Cross-bundle recognition
+
+`isUserError` matches on `error.name`, not `instanceof`. `toolcraft` publishes its
+own `UserError` (`packages/toolcraft/src/user-error.ts`) as a separately released
+framework, and an instance crossing a bundle boundary fails `instanceof` against
+this package's class. Name matching recognises both, and mirrors the existing
+`isSilentError()` precedent in `src/cli/errors.ts`. toolcraft deliberately does
+not depend on this package — the coupling would run the wrong way.
+
+## Config Options
+
+This package reads no configuration.
+
+## Environment Variables
+
+This package reads no environment variables.

package/node_modules/@poe-code/user-error/dist/index.d.ts

@@ -0,0 +1,17 @@
+/**
+ * An expected user mistake: bad input, a missing file, an unknown id, absent
+ * credentials. Thrown where the condition is detected so the CLI can render the
+ * message as guidance instead of dressing it in system-failure chrome.
+ */
+export declare class UserError extends Error {
+    readonly hint?: string;
+    constructor(message: string, options?: ErrorOptions & {
+        hint?: string;
+    });
+}
+/**
+ * Detects user errors by name as well as identity, so an instance created in
+ * another bundle (toolcraft publishes its own `UserError`) is still recognised
+ * where `instanceof` would fail.
+ */
+export declare function isUserError(error: unknown): boolean;

package/node_modules/@poe-code/user-error/dist/index.js

@@ -0,0 +1,21 @@
+/**
+ * An expected user mistake: bad input, a missing file, an unknown id, absent
+ * credentials. Thrown where the condition is detected so the CLI can render the
+ * message as guidance instead of dressing it in system-failure chrome.
+ */
+export class UserError extends Error {
+    hint;
+    constructor(message, options) {
+        super(message, options);
+        this.name = "UserError";
+        this.hint = options?.hint;
+    }
+}
+/**
+ * Detects user errors by name as well as identity, so an instance created in
+ * another bundle (toolcraft publishes its own `UserError`) is still recognised
+ * where `instanceof` would fail.
+ */
+export function isUserError(error) {
+    return error instanceof Error && error.name === "UserError";
+}

package/node_modules/@poe-code/user-error/package.json

@@ -0,0 +1,24 @@
+{
+  "private": true,
+  "license": "MIT",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "scripts": {
+    "build": "node ../../scripts/guard-package-dist.mjs && tsc"
+  },
+  "files": [
+    "dist"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/poe-platform/poe-code.git",
+    "directory": "packages/user-error"
+  }
+}

package/node_modules/tiny-stdio-mcp-server/dist/composition.json

@@ -8,7 +8,7 @@
     },
     {
       "name": "toolcraft-schema",
-      "version": "0.0.136",
+      "version": "0.0.138",
       "license": "MIT"
     }
   ]

package/node_modules/toolcraft-design/dist/acp/components.d.ts

@@ -1,4 +1,11 @@
-export declare function renderAgentMessage(text: string): void;
+/**
+ * Status of the agent output being rendered.
+ *
+ * `streaming` covers partial/in-progress content, which has not reached any outcome yet and so must not
+ * claim success. `success`/`error` are terminal outcomes known to the caller.
+ */
+export type AcpOutputState = "streaming" | "success" | "error";
+export declare function renderAgentMessage(text: string, state?: AcpOutputState): void;
 export declare function renderToolStart(kind: string, title: string): void;
 export declare function renderToolComplete(kind: string): void;
 export declare function renderReasoning(text: string): void;

package/node_modules/toolcraft-design/dist/acp/components.js

@@ -25,8 +25,13 @@ function colorForKind(kind) {
 function writeLine(line) {
     getAcpWriter()(line);
 }
-function agentPrefix() {
-    return `${color.green.bold("✓")} agent: `;
+const STATE_GLYPHS = {
+    streaming: () => color.dim("·"),
+    success: () => color.green.bold("✓"),
+    error: () => color.red.bold("✗")
+};
+function agentPrefix(state) {
+    return `${STATE_GLYPHS[state]()} agent: `;
 }
 function formatCost(costUsd) {
     return new Intl.NumberFormat("en-US", {
@@ -36,7 +41,7 @@ function formatCost(costUsd) {
         maximumFractionDigits: 6
     }).format(costUsd);
 }
-export function renderAgentMessage(text) {
+export function renderAgentMessage(text, state = "streaming") {
     const format = resolveOutputFormat();
     if (format === "markdown") {
         writeLine(`- **agent:** ${text}`);
@@ -47,7 +52,7 @@ export function renderAgentMessage(text) {
         return;
     }
     const rendered = renderMarkdown(text).trimEnd();
-    writeLine(`${agentPrefix()}${rendered}`);
+    writeLine(`${agentPrefix(state)}${rendered}`);
 }
 export function renderToolStart(kind, title) {
     const format = resolveOutputFormat();
@@ -85,7 +90,7 @@ export function renderReasoning(text) {
         writeLine(JSON.stringify({ event: "reasoning", text }));
         return;
     }
-    writeLine(color.dim(`  ✓ ${truncate(text, 80)}`));
+    writeLine(color.dim(`  · ${truncate(text, 80)}`));
 }
 export function renderUsage(tokens) {
     const format = resolveOutputFormat();
@@ -109,7 +114,7 @@ export function renderUsage(tokens) {
         return;
     }
     writeLine("");
-    writeLine(color.green(`✓ tokens: ${tokens.input} in${cached} → ${tokens.output} out${cost}`));
+    writeLine(color.dim(`· tokens: ${tokens.input} in${cached} → ${tokens.output} out${cost}`));
 }
 export function renderPermissionRejected(title) {
     const format = resolveOutputFormat();

package/node_modules/toolcraft-design/dist/acp/index.d.ts

@@ -1,3 +1,4 @@
 export { renderAgentMessage, renderToolStart, renderToolComplete, renderReasoning, renderUsage, renderError, renderPermissionRejected } from "./components.js";
+export type { AcpOutputState } from "./components.js";
 export { getAcpWriter, withAcpWriter } from "./writer.js";
 export type { AcpLineWriter } from "./writer.js";

package/node_modules/toolcraft-design/dist/components/command-errors.d.ts

@@ -1,6 +1,7 @@
 export declare function formatCommandNotFound(input: {
     unknownCommand: string;
     helpCommand: string;
+    suggestions?: readonly string[];
 }): {
     label: string;
     hint: string;
@@ -8,6 +9,7 @@ export declare function formatCommandNotFound(input: {
 export declare function formatCommandNotFoundPanel(input: {
     unknownCommand: string;
     helpCommand: string;
+    suggestions?: readonly string[];
     title?: string;
 }): {
     title: string;

package/node_modules/toolcraft-design/dist/components/command-errors.js

@@ -5,15 +5,21 @@ export function formatCommandNotFound(input) {
     const unknown = unknownInput.length > 0
         ? unknownInput
         : "<command>";
+    const suggestions = input.suggestions ?? [];
+    const didYouMean = suggestions.length > 0
+        ? `
+${text.muted("Did you mean:")} ${suggestions.map((suggestion) => text.command(suggestion)).join(text.muted(", "))}${text.muted("?")}`
+        : "";
     return {
-        label: `${typography.bold("Unknown command:")} ${text.command(unknown)}`,
+        label: `${typography.bold("Unknown command:")} ${text.command(unknown)}${didYouMean}`,
         hint: `${text.muted("Run")} ${text.usageCommand(input.helpCommand)} ${text.muted("for available commands.")}`
     };
 }
 export function formatCommandNotFoundPanel(input) {
     const message = formatCommandNotFound({
         unknownCommand: input.unknownCommand,
-        helpCommand: input.helpCommand
+        helpCommand: input.helpCommand,
+        suggestions: input.suggestions
     });
     return {
         title: input.title ?? "command not found",

package/node_modules/toolcraft-design/dist/components/index.d.ts

@@ -8,7 +8,7 @@ export { helpFormatter, formatColumns, formatCommand, formatUsage, formatOption,
 export type { CommandInfo, OptionInfo, FormatColumnsOptions, HelpToken, HelpTokenRole } from "./help-formatter.js";
 export { formatCommandNotFound } from "./command-errors.js";
 export { formatCommandNotFoundPanel } from "./command-errors.js";
-export { renderTable } from "./table.js";
+export { loggerTableWidth, renderTable } from "./table.js";
 export type { TableColumn, RenderTableOptions } from "./table.js";
 export { renderFileChanges } from "./file-changes.js";
 export type { FileChange, FileChangeDisplayMode, FileChangeKind, FileChangeOutputFormat, RenderFileChangesOptions } from "./file-changes.js";

package/node_modules/toolcraft-design/dist/components/index.js

@@ -5,7 +5,7 @@ export { createLogger, logger } from "./logger.js";
 export { helpFormatter, formatColumns, formatCommand, formatUsage, formatOption, formatCommandList, formatOptionList, styleHelpToken, joinHelpTokens, renderHelpTokens } from "./help-formatter.js";
 export { formatCommandNotFound } from "./command-errors.js";
 export { formatCommandNotFoundPanel } from "./command-errors.js";
-export { renderTable } from "./table.js";
+export { loggerTableWidth, renderTable } from "./table.js";
 export { renderFileChanges } from "./file-changes.js";
 export { renderCatalog } from "./catalog.js";
 export { getTemplatePartialNames, renderTemplate, resolveTemplatePartials } from "./template.js";

package/node_modules/toolcraft-design/dist/components/table.d.ts

@@ -12,4 +12,5 @@ export interface RenderTableOptions {
     variant?: "table" | "detail";
     maxWidth?: number;
 }
+export declare function loggerTableWidth(): number | undefined;
 export declare function renderTable(options: RenderTableOptions): string;

package/node_modules/toolcraft-design/dist/components/table.js

@@ -3,6 +3,7 @@ import { resolveOutputFormat } from "../internal/output-format.js";
 import { stripAnsi } from "../internal/strip-ansi.js";
 const reset = "\x1b[0m";
 const ellipsis = "…";
+const minCellWidth = 4;
 const graphemeSegmenter = new Intl.Segmenter(undefined, { granularity: "grapheme" });
 function getCell(row, name) {
     return Object.prototype.hasOwnProperty.call(row, name) ? row[name] ?? "" : "";
@@ -161,6 +162,51 @@ function computeColumns(columns) {
         width: getColumnWidth(column)
     }));
 }
+// Each column is framed as "│ cell ", plus the closing "│".
+function frameWidth(columnCount) {
+    return columnCount * 3 + 1;
+}
+// Log output indents every line with a "│  " guide, so a table emitted through the
+// logger has that much less room than the terminal. Undefined without a terminal:
+// piped output has no width to fit.
+export function loggerTableWidth() {
+    const columns = process.stdout.columns;
+    return columns === undefined ? undefined : columns - 3;
+}
+// Without an explicit budget or a TTY there is no width to fit: the consumer of the
+// piped output decides, so columns keep their declared widths.
+function budgetColumns(columns, maxWidth) {
+    if (maxWidth === undefined) {
+        return columns;
+    }
+    const available = maxWidth - frameWidth(columns.length);
+    const contentWidth = (cap) => columns.reduce((total, column) => total + Math.min(column.width, cap), 0);
+    if (columns.reduce((total, column) => total + column.width, 0) <= available) {
+        return columns;
+    }
+    // Widest-first: raise a shared cap as far as the budget allows, so narrow columns
+    // keep their declared width and only the columns above the cap lose room.
+    let cap = minCellWidth;
+    while (contentWidth(cap + 1) <= available) {
+        cap += 1;
+    }
+    const budgeted = columns.map((column) => ({ ...column, width: Math.min(column.width, cap) }));
+    let slack = available - contentWidth(cap);
+    while (slack > 0) {
+        const growable = budgeted.filter((column, index) => column.width < columns[index].width);
+        if (growable.length === 0) {
+            break;
+        }
+        for (const column of growable) {
+            if (slack === 0) {
+                break;
+            }
+            column.width += 1;
+            slack -= 1;
+        }
+    }
+    return budgeted;
+}
 function renderBorder(columns, theme, parts) {
     const horizontal = theme.muted("─");
     const segments = columns.map((column) => horizontal.repeat(column.width + 2));
@@ -247,16 +293,17 @@ function renderTableTerminal(options) {
     }
     const separatorOptions = options;
     const includeRowSeparators = separatorOptions.rowSeparator === true || separatorOptions.rowSeparators === true;
-    const top = renderBorder(computedColumns, theme, { left: "┌", mid: "┬", right: "┐" });
-    const header = renderTerminalRow(computedColumns.map((column) => theme.header(column.title)), computedColumns, theme);
-    const headerBottom = renderBorder(computedColumns, theme, { left: "├", mid: "┼", right: "┤" });
-    const bottom = renderBorder(computedColumns, theme, { left: "└", mid: "┴", right: "┘" });
+    const budgetedColumns = budgetColumns(computedColumns, options.maxWidth ?? process.stdout.columns);
+    const top = renderBorder(budgetedColumns, theme, { left: "┌", mid: "┬", right: "┐" });
+    const header = renderTerminalRow(budgetedColumns.map((column) => theme.header(column.title)), budgetedColumns, theme);
+    const headerBottom = renderBorder(budgetedColumns, theme, { left: "├", mid: "┼", right: "┤" });
+    const bottom = renderBorder(budgetedColumns, theme, { left: "└", mid: "┴", right: "┘" });
     const renderedRows = [];
     for (const [index, row] of rows.entries()) {
         if (includeRowSeparators && index > 0) {
             renderedRows.push(headerBottom);
         }
-        renderedRows.push(renderTerminalRow(computedColumns.map((column) => getCell(row, column.name)), computedColumns, theme));
+        renderedRows.push(renderTerminalRow(budgetedColumns.map((column) => getCell(row, column.name)), budgetedColumns, theme));
     }
     return [top, header, headerBottom, ...renderedRows, bottom].join("\n");
 }