toolcraft 0.0.1

package/dist/sdk.d.ts

@@ -0,0 +1,63 @@
+import type { ObjectSchema, Static } from "agent-kit-schema";
+import type { Group, Scope } from "./index.js";
+type ScopeInput = readonly Scope[] | undefined;
+type Primitive = string | number | boolean | bigint | symbol | null | undefined;
+type EmptyRecord = Record<never, never>;
+type EffectiveCommandScope<TOwnScope extends ScopeInput, TInheritedScope extends ScopeInput> = TOwnScope extends readonly Scope[] ? TOwnScope : TInheritedScope extends readonly Scope[] ? TInheritedScope : readonly ["cli", "sdk"];
+type EffectiveGroupScope<TOwnScope extends ScopeInput, TInheritedScope extends ScopeInput> = TOwnScope extends readonly Scope[] ? TOwnScope : TInheritedScope extends readonly Scope[] ? TInheritedScope : undefined;
+type IncludesSDK<TScope> = TScope extends readonly Scope[] ? "sdk" extends TScope[number] ? true : false : false;
+type Separator = "-" | "_" | " " | ".";
+type IsUppercase<TValue extends string> = TValue extends Uppercase<TValue> ? TValue extends Lowercase<TValue> ? false : true : false;
+type IsLowercase<TValue extends string> = TValue extends Lowercase<TValue> ? TValue extends Uppercase<TValue> ? false : true : false;
+type LastCharacter<TValue extends string> = TValue extends `${infer THead}${infer TTail}` ? TTail extends "" ? THead : LastCharacter<TTail> : never;
+type PushCurrentWord<TCurrent extends string, TWords extends readonly string[]> = TCurrent extends "" ? TWords : [...TWords, Lowercase<TCurrent>];
+type SplitCamelWords<TValue extends string, TCurrent extends string = "", TWords extends readonly string[] = []> = TValue extends `${infer TChar}${infer TRest}` ? TChar extends Separator ? SplitCamelWords<TRest, "", PushCurrentWord<TCurrent, TWords>> : IsUppercase<TChar> extends true ? TCurrent extends "" ? SplitCamelWords<TRest, TChar, TWords> : TRest extends `${infer TNext}${string}` ? IsLowercase<LastCharacter<TCurrent>> extends true ? SplitCamelWords<TRest, TChar, PushCurrentWord<TCurrent, TWords>> : IsLowercase<TNext> extends true ? SplitCamelWords<TRest, TChar, PushCurrentWord<TCurrent, TWords>> : SplitCamelWords<TRest, `${TCurrent}${TChar}`, TWords> : SplitCamelWords<TRest, `${TCurrent}${TChar}`, TWords> : SplitCamelWords<TRest, `${TCurrent}${TChar}`, TWords> : PushCurrentWord<TCurrent, TWords>;
+type JoinCamelWords<TWords extends readonly string[]> = TWords extends readonly [
+    infer THead extends string,
+    ...infer TTail extends readonly string[]
+] ? `${THead}${CapitalizeJoinCamelWords<TTail>}` : "";
+type CapitalizeJoinCamelWords<TWords extends readonly string[]> = TWords extends readonly [
+    infer THead extends string,
+    ...infer TTail extends readonly string[]
+] ? `${Capitalize<THead>}${CapitalizeJoinCamelWords<TTail>}` : "";
+type CamelCase<TValue extends string> = JoinCamelWords<SplitCamelWords<TValue>>;
+type Camelize<TValue> = TValue extends Primitive ? TValue : TValue extends readonly (infer TItem)[] ? Array<Camelize<TItem>> : TValue extends object ? {
+    [TKey in keyof TValue as TKey extends string ? CamelCase<TKey> : TKey]: Camelize<TValue[TKey]>;
+} : TValue;
+type SDKMethod<TParamsSchema extends ObjectSchema<any>, TResult> = (params: Camelize<Static<TParamsSchema>>) => Promise<TResult>;
+type UnionToIntersection<TValue> = (TValue extends unknown ? (value: TValue) => void : never) extends (value: infer TResult) => void ? TResult : never;
+type Simplify<TValue> = {
+    [TKey in keyof TValue]: TValue[TKey];
+};
+type RawChildrenValue<TChildren> = TChildren extends readonly unknown[] ? TChildren[number] : never;
+type SDKNodeShape<TNode, TInheritedScope extends ScopeInput> = TNode extends {
+    kind: "command";
+    readonly __agentKitCommandTypeInfo: {
+        name: infer TName extends string;
+        params: infer TParamsSchema extends ObjectSchema<any>;
+        result: infer TResult;
+        ownScope: infer TOwnScope extends ScopeInput;
+    };
+} ? IncludesSDK<EffectiveCommandScope<TOwnScope, TInheritedScope>> extends true ? {
+    [TKey in CamelCase<TName>]: SDKMethod<TParamsSchema, TResult>;
+} : EmptyRecord : TNode extends {
+    kind: "group";
+    readonly __agentKitGroupTypeInfo: {
+        name: infer TName extends string;
+        children: infer TChildren extends readonly unknown[];
+        ownScope: infer TOwnScope extends ScopeInput;
+    };
+} ? SDKChildrenShape<TChildren, EffectiveGroupScope<TOwnScope, TInheritedScope>> extends infer TChildShape extends object ? keyof TChildShape extends never ? EmptyRecord : {
+    [TKey in CamelCase<TName>]: TChildShape;
+} : never : EmptyRecord;
+type SDKChildrenShape<TChildren, TInheritedScope extends ScopeInput> = Simplify<UnionToIntersection<SDKNodeShape<RawChildrenValue<TChildren>, TInheritedScope>>>;
+export interface CreateSDKOptions<TServices extends object = Record<string, unknown>> {
+    services?: TServices;
+    casing?: "camel";
+}
+export declare function createSDK<TRootInfo, TServices extends object = Record<string, unknown>>(root: Group<any> & {
+    readonly __agentKitGroupTypeInfo: TRootInfo;
+}, options?: CreateSDKOptions<TServices>): TRootInfo extends {
+    children: infer TChildren extends readonly unknown[];
+} ? SDKChildrenShape<TChildren, undefined> : EmptyRecord;
+export {};

package/dist/sdk.js

@@ -0,0 +1,218 @@
+import { access, readFile, writeFile } from "node:fs/promises";
+import { UserError, assertCommandRequirements, resolveCommandSecrets } from "./index.js";
+import { getExpectedNumberDescription, isValidNumberSchemaValue } from "./number-schema.js";
+import { filterSchemaForScope } from "./schema-scope.js";
+const RESERVED_SERVICE_NAMES = new Set(["params", "secrets", "fetch", "fs", "env", "progress"]);
+function splitWords(value) {
+    const words = [];
+    let current = "";
+    for (let index = 0; index < value.length; index += 1) {
+        const char = value[index] ?? "";
+        const lower = char.toLowerCase();
+        const upper = char.toUpperCase();
+        const isSeparator = char === "-" || char === "_" || char === " " || char === ".";
+        if (isSeparator) {
+            if (current.length > 0) {
+                words.push(current.toLowerCase());
+                current = "";
+            }
+            continue;
+        }
+        const isUppercase = char !== lower && char === upper;
+        const previous = value[index - 1];
+        const next = value[index + 1];
+        const previousIsLowercase = previous !== undefined && previous === previous.toLowerCase() && previous !== previous.toUpperCase();
+        const nextIsLowercase = next !== undefined && next === next.toLowerCase() && next !== next.toUpperCase();
+        if (isUppercase && current.length > 0 && (previousIsLowercase || nextIsLowercase)) {
+            words.push(current.toLowerCase());
+            current = char;
+            continue;
+        }
+        current += char;
+    }
+    if (current.length > 0) {
+        words.push(current.toLowerCase());
+    }
+    return words;
+}
+function formatSegment(segment) {
+    return splitWords(segment)
+        .map((word, index) => (index === 0 ? word : `${word[0]?.toUpperCase() ?? ""}${word.slice(1)}`))
+        .join("");
+}
+function unwrapOptional(schema) {
+    if (schema.kind === "optional") {
+        return unwrapOptional(schema.inner);
+    }
+    return schema;
+}
+function isOptional(schema) {
+    return schema.kind === "optional";
+}
+function isPlainObject(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function createFs() {
+    return {
+        readFile: async (path, encoding = "utf8") => readFile(path, { encoding }),
+        writeFile: async (path, contents) => {
+            await writeFile(path, contents);
+        },
+        exists: async (path) => {
+            try {
+                await access(path);
+                return true;
+            }
+            catch {
+                return false;
+            }
+        },
+    };
+}
+function createEnv(values = process.env) {
+    return {
+        get(key) {
+            return values[key];
+        },
+    };
+}
+function validateServices(services) {
+    for (const name of Object.keys(services)) {
+        if (RESERVED_SERVICE_NAMES.has(name)) {
+            throw new Error(`Service name "${name}" is reserved. Choose a different name.`);
+        }
+    }
+}
+function validateEnum(value, schema, label) {
+    if (!schema.values.includes(value)) {
+        throw new UserError(`Invalid value for "${label}". Expected one of: ${schema.values.map((candidate) => String(candidate)).join(", ")}.`);
+    }
+    return value;
+}
+function validateSchemaValue(schema, value, label) {
+    const unwrappedSchema = unwrapOptional(schema);
+    if (value === null && unwrappedSchema.nullable === true) {
+        return null;
+    }
+    switch (unwrappedSchema.kind) {
+        case "string":
+            if (typeof value !== "string") {
+                throw new UserError(`Invalid value for "${label}". Expected a string.`);
+            }
+            return value;
+        case "number":
+            if (!isValidNumberSchemaValue(value, unwrappedSchema)) {
+                throw new UserError(`Invalid value for "${label}". Expected ${getExpectedNumberDescription(unwrappedSchema)}.`);
+            }
+            return value;
+        case "boolean":
+            if (typeof value !== "boolean") {
+                throw new UserError(`Invalid value for "${label}". Expected a boolean.`);
+            }
+            return value;
+        case "enum":
+            return validateEnum(value, unwrappedSchema, label);
+        case "array":
+            if (!Array.isArray(value)) {
+                throw new UserError(`Invalid value for "${label}". Expected an array.`);
+            }
+            return value.map((item, index) => validateSchemaValue(unwrappedSchema.item, item, `${label}[${index}]`));
+        case "object":
+            return validateObjectSchema(unwrappedSchema, value, label);
+    }
+}
+function validateObjectSchema(schema, value, label) {
+    if (!isPlainObject(value)) {
+        throw new UserError(`Invalid value for "${label}". Expected an object.`);
+    }
+    const result = {};
+    const expectedKeys = new Map();
+    for (const [key, childSchema] of Object.entries(schema.shape)) {
+        expectedKeys.set(formatSegment(key), [key, childSchema]);
+    }
+    for (const key of Object.keys(value)) {
+        if (!expectedKeys.has(key)) {
+            const fieldLabel = label.length === 0 ? key : `${label}.${key}`;
+            throw new UserError(`Unexpected parameter "${fieldLabel}".`);
+        }
+    }
+    for (const [inputKey, [outputKey, rawChildSchema]] of expectedKeys.entries()) {
+        const childSchema = unwrapOptional(rawChildSchema);
+        const hasValue = Object.prototype.hasOwnProperty.call(value, inputKey);
+        const fieldLabel = label.length === 0 ? inputKey : `${label}.${inputKey}`;
+        if (!hasValue) {
+            if (childSchema.default !== undefined) {
+                result[outputKey] = childSchema.default;
+                continue;
+            }
+            if (isOptional(rawChildSchema)) {
+                continue;
+            }
+            throw new UserError(`Missing required parameter "${fieldLabel}".`);
+        }
+        result[outputKey] = validateSchemaValue(rawChildSchema, value[inputKey], fieldLabel);
+    }
+    return result;
+}
+function validateSDKArguments(schema, argumentsValue) {
+    return validateObjectSchema(schema, argumentsValue ?? {}, "");
+}
+function defineMember(target, key, value) {
+    if (Object.prototype.hasOwnProperty.call(target, key)) {
+        throw new Error(`Duplicate SDK member "${key}".`);
+    }
+    Object.defineProperty(target, key, {
+        value,
+        enumerable: true,
+        configurable: false,
+        writable: false,
+    });
+}
+export function createSDK(root, options = {}) {
+    const services = options.services ?? {};
+    void options.casing;
+    validateServices(services);
+    function build(node) {
+        if (node.kind === "command") {
+            return async (params) => {
+                const secrets = resolveCommandSecrets(node);
+                const baseContext = {
+                    ...services,
+                    secrets,
+                    fetch: globalThis.fetch,
+                    fs: createFs(),
+                    env: createEnv(),
+                    progress() {
+                        return undefined;
+                    },
+                };
+                await assertCommandRequirements(node, { ...baseContext, params: undefined });
+                const paramsSchema = filterSchemaForScope(node.params, "sdk");
+                if (paramsSchema === undefined || paramsSchema.kind !== "object") {
+                    throw new Error(`Bug: command "${node.name}" must define an object params schema for SDK.`);
+                }
+                const validatedParams = validateSDKArguments(paramsSchema, params);
+                return node.handler({
+                    ...baseContext,
+                    params: validatedParams,
+                });
+            };
+        }
+        const output = {};
+        for (const child of node.children) {
+            if (child.kind === "command") {
+                if (!child.scope.includes("sdk")) {
+                    continue;
+                }
+                defineMember(output, formatSegment(child.name), build(child));
+                continue;
+            }
+            const childValue = build(child);
+            if (isPlainObject(childValue) && Object.keys(childValue).length > 0) {
+                defineMember(output, formatSegment(child.name), childValue);
+            }
+        }
+        return output;
+    }
+    return build(root);
+}

package/node_modules/@poe-code/design-system/dist/acp/components.d.ts

@@ -0,0 +1,11 @@
+export declare function renderAgentMessage(text: string): void;
+export declare function renderToolStart(kind: string, title: string): void;
+export declare function renderToolComplete(kind: string): void;
+export declare function renderReasoning(text: string): void;
+export declare function renderUsage(tokens: {
+    input: number;
+    output: number;
+    cached?: number;
+    costUsd?: number;
+}): void;
+export declare function renderError(message: string): void;

package/node_modules/@poe-code/design-system/dist/acp/components.js

@@ -0,0 +1,121 @@
+import chalk from "chalk";
+import { resolveOutputFormat } from "../internal/output-format.js";
+import { renderMarkdown } from "../terminal-markdown/index.js";
+import { getAcpWriter } from "./writer.js";
+function truncate(text, maxLength) {
+    if (text.length <= maxLength)
+        return text;
+    if (maxLength <= 3)
+        return text.slice(0, maxLength);
+    return `${text.slice(0, maxLength - 3)}...`;
+}
+const KIND_COLORS = {
+    exec: (text) => chalk.yellow(text),
+    edit: (text) => chalk.magenta(text),
+    read: (text) => chalk.cyan(text),
+    search: (text) => chalk.blue(text),
+    think: (text) => chalk.dim(text),
+    other: (text) => chalk.dim(text)
+};
+function colorForKind(kind) {
+    return KIND_COLORS[kind] ?? ((text) => chalk.dim(text));
+}
+function writeLine(line) {
+    getAcpWriter()(line);
+}
+const AGENT_PREFIX = `${chalk.green.bold("✓")} agent: `;
+function formatCost(costUsd) {
+    return new Intl.NumberFormat("en-US", {
+        style: "currency",
+        currency: "USD",
+        minimumFractionDigits: 2,
+        maximumFractionDigits: 6
+    }).format(costUsd);
+}
+export function renderAgentMessage(text) {
+    const format = resolveOutputFormat();
+    if (format === "markdown") {
+        writeLine(`- **agent:** ${text}`);
+        return;
+    }
+    if (format === "json") {
+        writeLine(JSON.stringify({ event: "agent_message", text }));
+        return;
+    }
+    const rendered = renderMarkdown(text).trimEnd();
+    writeLine(`${AGENT_PREFIX}${rendered}`);
+}
+export function renderToolStart(kind, title) {
+    const format = resolveOutputFormat();
+    if (format === "markdown") {
+        writeLine(`- *→ ${kind}: ${title}*`);
+        return;
+    }
+    if (format === "json") {
+        writeLine(JSON.stringify({ event: "tool_start", kind, title }));
+        return;
+    }
+    const color = colorForKind(kind);
+    writeLine(color(`  → ${kind}: ${title}`));
+}
+export function renderToolComplete(kind) {
+    const format = resolveOutputFormat();
+    if (format === "markdown") {
+        writeLine(`- *✓ ${kind}*`);
+        return;
+    }
+    if (format === "json") {
+        writeLine(JSON.stringify({ event: "tool_complete", kind }));
+        return;
+    }
+    const color = colorForKind(kind);
+    writeLine(color(`  ✓ ${kind}`));
+}
+export function renderReasoning(text) {
+    const format = resolveOutputFormat();
+    if (format === "markdown") {
+        writeLine(`- *thinking:* ${truncate(text, 80)}`);
+        return;
+    }
+    if (format === "json") {
+        writeLine(JSON.stringify({ event: "reasoning", text }));
+        return;
+    }
+    writeLine(chalk.dim(`  ✓ ${truncate(text, 80)}`));
+}
+export function renderUsage(tokens) {
+    const format = resolveOutputFormat();
+    const cached = typeof tokens.cached === "number" && tokens.cached > 0 ? ` (${tokens.cached} cached)` : "";
+    let cost = "";
+    if (typeof tokens.costUsd === "number") {
+        cost = ` (${formatCost(tokens.costUsd)})`;
+    }
+    if (format === "markdown") {
+        writeLine(`- **tokens:** ${tokens.input} in → ${tokens.output} out${cost}`);
+        return;
+    }
+    if (format === "json") {
+        writeLine(JSON.stringify({
+            event: "usage",
+            inputTokens: tokens.input,
+            outputTokens: tokens.output,
+            cachedTokens: tokens.cached ?? 0,
+            costUsd: tokens.costUsd ?? 0
+        }));
+        return;
+    }
+    writeLine("");
+    writeLine(chalk.green(`✓ tokens: ${tokens.input} in${cached} → ${tokens.output} out${cost}`));
+}
+export function renderError(message) {
+    const format = resolveOutputFormat();
+    if (format === "markdown") {
+        writeLine(`- **error:** ${message}`);
+        return;
+    }
+    if (format === "json") {
+        writeLine(JSON.stringify({ event: "error", message }));
+        return;
+    }
+    writeLine(chalk.red(`✗ ${message}`));
+}

package/node_modules/@poe-code/design-system/dist/acp/index.d.ts

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

package/node_modules/@poe-code/design-system/dist/acp/index.js

@@ -0,0 +1,2 @@
+export { renderAgentMessage, renderToolStart, renderToolComplete, renderReasoning, renderUsage, renderError } from "./components.js";
+export { getAcpWriter, withAcpWriter } from "./writer.js";

package/node_modules/@poe-code/design-system/dist/acp/writer.d.ts

@@ -0,0 +1,13 @@
+export type AcpLineWriter = (line: string) => void;
+/**
+ * Return the writer active in the current async context, or the default
+ * stdout writer if none is bound.
+ */
+export declare function getAcpWriter(): AcpLineWriter;
+/**
+ * Run `fn` with `writer` bound as the active ACP line writer. All calls to
+ * `renderAgentMessage`, `renderToolStart`, `renderAcpEvent`, etc. made inside
+ * `fn` (or async work awaited from `fn`) will go through `writer` instead of
+ * writing to `process.stdout`.
+ */
+export declare function withAcpWriter<T>(writer: AcpLineWriter, fn: () => Promise<T>): Promise<T>;

package/node_modules/@poe-code/design-system/dist/acp/writer.js

@@ -0,0 +1,21 @@
+import { AsyncLocalStorage } from "node:async_hooks";
+const storage = new AsyncLocalStorage();
+const defaultWriter = (line) => {
+    process.stdout.write(`${line}\n`);
+};
+/**
+ * Return the writer active in the current async context, or the default
+ * stdout writer if none is bound.
+ */
+export function getAcpWriter() {
+    return storage.getStore() ?? defaultWriter;
+}
+/**
+ * Run `fn` with `writer` bound as the active ACP line writer. All calls to
+ * `renderAgentMessage`, `renderToolStart`, `renderAcpEvent`, etc. made inside
+ * `fn` (or async work awaited from `fn`) will go through `writer` instead of
+ * writing to `process.stdout`.
+ */
+export function withAcpWriter(writer, fn) {
+    return storage.run(writer, fn);
+}

package/node_modules/@poe-code/design-system/dist/components/command-errors.d.ts

@@ -0,0 +1,16 @@
+export declare function formatCommandNotFound(input: {
+    unknownCommand: string;
+    helpCommand: string;
+}): {
+    label: string;
+    hint: string;
+};
+export declare function formatCommandNotFoundPanel(input: {
+    unknownCommand: string;
+    helpCommand: string;
+    title?: string;
+}): {
+    title: string;
+    label: string;
+    footer: string;
+};

package/node_modules/@poe-code/design-system/dist/components/command-errors.js

@@ -0,0 +1,22 @@
+import { typography } from "../tokens/typography.js";
+import { text } from "./text.js";
+export function formatCommandNotFound(input) {
+    const unknown = input.unknownCommand.length > 0
+        ? input.unknownCommand
+        : "<command>";
+    return {
+        label: `${typography.bold("Unknown command:")} ${text.command(unknown)}`,
+        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
+    });
+    return {
+        title: input.title ?? "command not found",
+        label: message.label,
+        footer: message.hint
+    };
+}

package/node_modules/@poe-code/design-system/dist/components/help-formatter.d.ts

@@ -0,0 +1,20 @@
+export interface CommandInfo {
+    name: string;
+    description: string;
+}
+export interface OptionInfo {
+    flags: string;
+    description: string;
+}
+export declare function formatCommand(name: string, description: string): string;
+export declare function formatUsage(command: string, args?: string): string;
+export declare function formatOption(flags: string, description: string): string;
+export declare function formatCommandList(commands: CommandInfo[]): string;
+export declare function formatOptionList(options: OptionInfo[]): string;
+export declare const helpFormatter: {
+    readonly formatCommand: typeof formatCommand;
+    readonly formatUsage: typeof formatUsage;
+    readonly formatOption: typeof formatOption;
+    readonly formatCommandList: typeof formatCommandList;
+    readonly formatOptionList: typeof formatOptionList;
+};

package/node_modules/@poe-code/design-system/dist/components/help-formatter.js

@@ -0,0 +1,27 @@
+import { text } from "./text.js";
+import { widths } from "../tokens/widths.js";
+export function formatCommand(name, description) {
+    const paddedName = name.padEnd(widths.helpColumn);
+    return `  ${text.command(paddedName)}  ${description}`;
+}
+export function formatUsage(command, args) {
+    const argsStr = args ? ` ${text.argument(args)}` : "";
+    return `${text.usageCommand(command)}${argsStr}`;
+}
+export function formatOption(flags, description) {
+    const paddedFlags = flags.padEnd(widths.helpColumn);
+    return `  ${text.option(paddedFlags)}  ${description}`;
+}
+export function formatCommandList(commands) {
+    return commands.map((cmd) => formatCommand(cmd.name, cmd.description)).join("\n");
+}
+export function formatOptionList(options) {
+    return options.map((opt) => formatOption(opt.flags, opt.description)).join("\n");
+}
+export const helpFormatter = {
+    formatCommand,
+    formatUsage,
+    formatOption,
+    formatCommandList,
+    formatOptionList
+};

package/node_modules/@poe-code/design-system/dist/components/index.d.ts

@@ -0,0 +1,10 @@
+export { text } from "./text.js";
+export { symbols } from "./symbols.js";
+export { createLogger, logger } from "./logger.js";
+export type { LoggerOutput } from "./logger.js";
+export { helpFormatter, formatCommand, formatUsage, formatOption, formatCommandList, formatOptionList } from "./help-formatter.js";
+export type { CommandInfo, OptionInfo } from "./help-formatter.js";
+export { formatCommandNotFound } from "./command-errors.js";
+export { formatCommandNotFoundPanel } from "./command-errors.js";
+export { renderTable } from "./table.js";
+export type { TableColumn, RenderTableOptions } from "./table.js";

package/node_modules/@poe-code/design-system/dist/components/index.js

@@ -0,0 +1,7 @@
+export { text } from "./text.js";
+export { symbols } from "./symbols.js";
+export { createLogger, logger } from "./logger.js";
+export { helpFormatter, formatCommand, formatUsage, formatOption, formatCommandList, formatOptionList } from "./help-formatter.js";
+export { formatCommandNotFound } from "./command-errors.js";
+export { formatCommandNotFoundPanel } from "./command-errors.js";
+export { renderTable } from "./table.js";

package/node_modules/@poe-code/design-system/dist/components/logger.d.ts

@@ -0,0 +1,11 @@
+export interface LoggerOutput {
+    info(message: string): void;
+    success(message: string): void;
+    warn(message: string): void;
+    error(message: string): void;
+    resolved(label: string, value: string): void;
+    errorResolved(label: string, value: string): void;
+    message(message: string, symbol?: string): void;
+}
+export declare function createLogger(emitter?: (message: string) => void): LoggerOutput;
+export declare const logger: LoggerOutput;

package/node_modules/@poe-code/design-system/dist/components/logger.js

@@ -0,0 +1,60 @@
+import chalk from "chalk";
+import { log } from "../prompts/primitives/log.js";
+import { symbols } from "./symbols.js";
+export function createLogger(emitter) {
+    const emit = (level, message) => {
+        if (emitter) {
+            emitter(message);
+            return;
+        }
+        if (level === "success") {
+            log.success(message);
+            return;
+        }
+        if (level === "warn") {
+            log.warn(message);
+            return;
+        }
+        if (level === "error") {
+            log.error(message);
+            return;
+        }
+        log.info(message);
+    };
+    return {
+        info(message) {
+            emit("info", message);
+        },
+        success(message) {
+            emit("success", message);
+        },
+        warn(message) {
+            emit("warn", message);
+        },
+        error(message) {
+            emit("error", message);
+        },
+        resolved(label, value) {
+            if (emitter) {
+                emitter(`${label}: ${value}`);
+                return;
+            }
+            log.message(`${label}\n   ${value}`, { symbol: symbols.resolved });
+        },
+        errorResolved(label, value) {
+            if (emitter) {
+                emitter(`${label}: ${value}`);
+                return;
+            }
+            log.message(`${label}\n   ${value}`, { symbol: symbols.errorResolved });
+        },
+        message(message, symbol) {
+            if (emitter) {
+                emitter(message);
+                return;
+            }
+            log.message(message, { symbol: symbol ?? chalk.gray("│") });
+        }
+    };
+}
+export const logger = createLogger();

package/node_modules/@poe-code/design-system/dist/components/symbols.d.ts

@@ -0,0 +1,12 @@
+export declare const symbols: {
+    readonly info: string;
+    readonly success: string;
+    readonly resolved: string;
+    readonly errorResolved: string;
+    readonly bar: string;
+    readonly cornerTopRight: "╮";
+    readonly cornerBottomRight: "╯";
+    readonly warning: string;
+    readonly active: string;
+    readonly inactive: string;
+};