toolcraft 0.0.5 → 0.0.7

package/README.md

@@ -441,6 +441,7 @@ If you have an existing MCP server you want to keep running, use the MCP proxy:
 - `casing?: "kebab" | "snake"` — generated CLI flag style.
 - `services?: TServices` — merged into every handler context.
 - `version?: string` — surfaced via `--version`.
+- `presets?: boolean` — enables `--preset <path>` for loading parameter defaults from JSON files.
 - `apiVersion?: string` — for `requires.apiVersion`.
 - `humanInLoop?: HumanInLoopRuntimeOptions`
 

package/dist/cli.d.ts

@@ -9,6 +9,7 @@ export interface RunCLIOptions<TServices extends object = Record<string, unknown
     rootUsageName?: string;
     services?: TServices;
     version?: string;
+    presets?: boolean;
 }
 export declare function runCLI<TServices extends object = Record<string, unknown>>(roots: Group<TServices> | Group<TServices>[], options?: RunCLIOptions<TServices>): Promise<void>;
 export {};

package/dist/cli.js

@@ -126,7 +126,7 @@ function getRequiredBranchFingerprint(branch, casing) {
         .sort();
     return requiredKeys.join("+");
 }
-function collectFields(schema, casing, path = [], inheritedOptional = false, variantContext) {
+function collectFields(schema, casing, globalLongOptionFlags, path = [], inheritedOptional = false, variantContext) {
     const collected = {
         dynamicFields: [],
         fields: [],
@@ -138,7 +138,7 @@ function collectFields(schema, casing, path = [], inheritedOptional = false, var
         const childSchema = unwrapOptional(rawChildSchema);
         const requiredWhenActive = rawChildSchema.kind !== "optional" && childSchema.default === undefined;
         if (childSchema.kind === "object") {
-            const nested = collectFields(childSchema, casing, nextPath, runtimeOptional, variantContext);
+            const nested = collectFields(childSchema, casing, globalLongOptionFlags, nextPath, runtimeOptional, variantContext);
             collected.dynamicFields.push(...nested.dynamicFields);
             collected.fields.push(...nested.fields);
             collected.variants.push(...nested.variants);
@@ -152,7 +152,7 @@ function collectFields(schema, casing, path = [], inheritedOptional = false, var
                 path: [...nextPath, childSchema.discriminator],
                 displayPath: toDisplayPath([...nextPath, childSchema.discriminator]),
                 optionAttribute: toOptionAttribute([...nextPath, childSchema.discriminator], casing),
-                commanderOptionAttribute: toCommanderOptionAttribute([...nextPath, childSchema.discriminator], casing),
+                commanderOptionAttribute: toCommanderOptionAttribute([...nextPath, childSchema.discriminator], casing, globalLongOptionFlags),
                 optionFlag: toOptionFlag([...nextPath, childSchema.discriminator], casing),
                 shortFlag: undefined,
                 schema: createSyntheticEnumSchema(branchIds),
@@ -165,7 +165,7 @@ function collectFields(schema, casing, path = [], inheritedOptional = false, var
             collected.fields.push(controlField);
             const branches = [];
             for (const [branchId, branchSchema] of Object.entries(childSchema.branches)) {
-                const branch = collectFields(branchSchema, casing, nextPath, true, {
+                const branch = collectFields(branchSchema, casing, globalLongOptionFlags, nextPath, true, {
                     id: variantId,
                     branchId,
                 });
@@ -203,7 +203,7 @@ function collectFields(schema, casing, path = [], inheritedOptional = false, var
                 path: controlPath,
                 displayPath: controlDisplayPath,
                 optionAttribute: toOptionAttribute(controlPath, casing),
-                commanderOptionAttribute: toCommanderOptionAttribute(controlPath, casing),
+                commanderOptionAttribute: toCommanderOptionAttribute(controlPath, casing, globalLongOptionFlags),
                 optionFlag: toOptionFlag(controlPath, casing),
                 shortFlag: undefined,
                 schema: createSyntheticEnumSchema(branchIds),
@@ -218,7 +218,7 @@ function collectFields(schema, casing, path = [], inheritedOptional = false, var
             const branches = [];
             childSchema.branches.forEach((branchSchema, index) => {
                 const branchId = branchIds[index] ?? "";
-                const branch = collectFields(branchSchema, casing, nextPath, true, {
+                const branch = collectFields(branchSchema, casing, globalLongOptionFlags, nextPath, true, {
                     id: variantId,
                     branchId,
                 });
@@ -289,7 +289,7 @@ function collectFields(schema, casing, path = [], inheritedOptional = false, var
             path: nextPath,
             displayPath: toDisplayPath(nextPath),
             optionAttribute: toOptionAttribute(nextPath, casing),
-            commanderOptionAttribute: toCommanderOptionAttribute(nextPath, casing),
+            commanderOptionAttribute: toCommanderOptionAttribute(nextPath, casing, globalLongOptionFlags),
             optionFlag: toOptionFlag(nextPath, casing),
             shortFlag: childSchema.short,
             schema: childSchema,
@@ -304,10 +304,10 @@ function collectFields(schema, casing, path = [], inheritedOptional = false, var
     }
     return collected;
 }
-function toCommanderOptionAttribute(path, casing) {
+function toCommanderOptionAttribute(path, casing, globalLongOptionFlags) {
     const optionAttribute = toOptionAttribute(path, casing);
     const optionFlag = toOptionFlag(path, casing);
-    if (!GLOBAL_LONG_OPTION_FLAGS.has(optionFlag)) {
+    if (!globalLongOptionFlags.has(optionFlag)) {
         return optionAttribute;
     }
     return `param_${optionAttribute}`;
@@ -337,8 +337,8 @@ function assignPositionals(fields, positional) {
     });
     return fields;
 }
-function formatOptionFlags(field) {
-    const collidesWithGlobalFlag = GLOBAL_LONG_OPTION_FLAGS.has(field.optionFlag);
+function formatOptionFlags(field, globalLongOptionFlags) {
+    const collidesWithGlobalFlag = globalLongOptionFlags.has(field.optionFlag);
     if (collidesWithGlobalFlag) {
         if (field.shortFlag === undefined) {
             throw new UserError(`Parameter "${field.displayPath}" uses reserved CLI flag "${field.optionFlag}". Add a short flag or rename the parameter.`);
@@ -449,9 +449,9 @@ function parseArrayValue(value, schema, label) {
     }
     return splitArrayInput(value).map((item) => parseScalarValue(item, itemSchema, label));
 }
-function createOption(field) {
-    const flags = formatOptionFlags(field);
-    const collidesWithGlobalFlag = GLOBAL_LONG_OPTION_FLAGS.has(field.optionFlag);
+function createOption(field, globalLongOptionFlags) {
+    const flags = formatOptionFlags(field, globalLongOptionFlags);
+    const collidesWithGlobalFlag = globalLongOptionFlags.has(field.optionFlag);
     const commanderValue = (value) => (value === null ? NULL_OPTION_VALUE : value);
     if (field.schema.kind === "boolean") {
         if (collidesWithGlobalFlag) {
@@ -489,7 +489,10 @@ function createOption(field) {
     option.argParser((value) => commanderValue(parseScalarValue(value, field.schema, field.displayPath)));
     return [option];
 }
-const GLOBAL_LONG_OPTION_FLAGS = new Set(["--preset", "--yes", "--output", "--verbose"]);
+const ALWAYS_GLOBAL_LONG_OPTION_FLAGS = ["--yes", "--output", "--verbose"];
+function getGlobalLongOptionFlags(presetsEnabled) {
+    return new Set(presetsEnabled ? ["--preset", ...ALWAYS_GLOBAL_LONG_OPTION_FLAGS] : ALWAYS_GLOBAL_LONG_OPTION_FLAGS);
+}
 function createCommanderOption(flags, description, field) {
     const option = new Option(flags, description);
     if (field.commanderOptionAttribute !== field.optionAttribute) {
@@ -580,14 +583,14 @@ function describeSchemaType(schema) {
             throw new UserError("Unsupported CLI schema kind.");
     }
 }
-function formatHelpFieldFlags(field) {
+function formatHelpFieldFlags(field, globalLongOptionFlags) {
     if (field.positionalIndex !== undefined) {
         return formatPositionalToken(field);
     }
     if (field.schema.kind === "boolean") {
-        return `${formatOptionFlags(field)} [value]`;
+        return `${formatOptionFlags(field, globalLongOptionFlags)} [value]`;
     }
-    return `${formatOptionFlags(field)} <${describeSchemaType(field.schema)}>`;
+    return `${formatOptionFlags(field, globalLongOptionFlags)} <${describeSchemaType(field.schema)}>`;
 }
 function appendHelpMetadata(description, metadata) {
     if (metadata.length === 0) {
@@ -711,31 +714,40 @@ function formatSecretDescription(secret) {
     }
     return secret.optional === true ? "Optional secret" : "Required secret";
 }
-function formatCommandRows(group, scope) {
-    return getVisibleChildren(group, scope).map((child) => ({
-        name: child.aliases.length === 0 ? child.name : `${child.name} (${child.aliases.join(", ")})`,
-        description: child.description ?? "",
-    }));
+function formatCommandRowName(node, depth) {
+    const name = node.aliases.length === 0 ? node.name : `${node.name} (${node.aliases.join(", ")})`;
+    return `${"  ".repeat(depth)}${name}`;
+}
+function formatCommandRows(group, scope, depth = 0) {
+    return getVisibleChildren(group, scope).flatMap((child) => {
+        const row = {
+            name: formatCommandRowName(child, depth),
+            description: child.description ?? "",
+        };
+        if (child.kind === "command") {
+            return [row];
+        }
+        return [row, ...formatCommandRows(child, scope, depth + 1)];
+    });
 }
-function formatGlobalOptionRows(showVersion) {
-    const rows = [
-        {
+function formatGlobalOptionRows(showVersion, presetsEnabled) {
+    const rows = [];
+    if (presetsEnabled) {
+        rows.push({
             flags: "--preset <path>",
             description: "Load parameter defaults from a JSON file",
-        },
-        {
-            flags: "--yes",
-            description: "Accept defaults, skip prompts",
-        },
-        {
-            flags: "--output <format>",
-            description: "Output format (rich, md, json)",
-        },
-        {
-            flags: "-h, --help",
-            description: "Show help",
-        },
-    ];
+        });
+    }
+    rows.push({
+        flags: "--yes",
+        description: "Accept defaults, skip prompts",
+    }, {
+        flags: "--output <format>",
+        description: "Output format (rich, md, json)",
+    }, {
+        flags: "-h, --help",
+        description: "Show help",
+    });
     if (showVersion) {
         rows.push({
             flags: "--version",
@@ -754,13 +766,13 @@ function buildUsageLine(breadcrumb, rootUsageName, suffix) {
     const subPath = breadcrumb.slice(1).join(" ");
     return subPath ? `${rootUsageName} ${subPath} ${suffix}` : `${rootUsageName} ${suffix}`;
 }
-function renderGroupHelp(group, breadcrumb, scope, showVersion, rootUsageName) {
+function renderGroupHelp(group, breadcrumb, scope, showVersion, presetsEnabled, rootUsageName) {
     const sections = [];
     const commandRows = formatCommandRows(group, scope);
     if (commandRows.length > 0) {
         sections.push(`${text.section("Commands:")}\n${formatCommandList(commandRows)}`);
     }
-    sections.push(`${text.section("Global options:")}\n${formatOptionList(formatGlobalOptionRows(showVersion))}`);
+    sections.push(`${text.section("Global options:")}\n${formatOptionList(formatGlobalOptionRows(showVersion, presetsEnabled))}`);
     return renderHelpDocument({
         breadcrumb,
         usageLine: buildUsageLine(breadcrumb, rootUsageName, "[options] [command]"),
@@ -769,18 +781,19 @@ function renderGroupHelp(group, breadcrumb, scope, showVersion, rootUsageName) {
         sections,
     });
 }
-function renderLeafHelp(command, breadcrumb, casing, rootUsageName) {
+function renderLeafHelp(command, breadcrumb, casing, presetsEnabled, rootUsageName) {
     const sections = [];
-    const collected = collectFields(command.params, casing);
+    const globalLongOptionFlags = getGlobalLongOptionFlags(presetsEnabled);
+    const collected = collectFields(command.params, casing, globalLongOptionFlags);
     const fields = assignPositionals(collected.fields, command.positional);
     const optionRows = fields.map((field) => ({
-        flags: formatHelpFieldFlags(field),
+        flags: formatHelpFieldFlags(field, globalLongOptionFlags),
         description: formatHelpFieldDescription(field),
     })).concat(collected.dynamicFields.flatMap((field) => formatDynamicHelpFields(field, casing)));
     if (optionRows.length > 0) {
         sections.push(`${text.section("Options:")}\n${formatOptionList(optionRows)}`);
     }
-    sections.push(`${text.section("Global options:")}\n${formatOptionList(formatGlobalOptionRows(false))}`);
+    sections.push(`${text.section("Global options:")}\n${formatOptionList(formatGlobalOptionRows(false, presetsEnabled))}`);
     const secretRows = formatSecretRows(command.secrets);
     if (secretRows.length > 0) {
         sections.push(`${text.section("Secrets (via environment):")}\n${formatOptionList(secretRows)}`);
@@ -820,26 +833,26 @@ async function renderGeneratedHelp(root, argv, options) {
     const casing = options.casing ?? "kebab";
     await withOutputFormat(output, async () => {
         const rendered = target.node.kind === "group"
-            ? renderGroupHelp(target.node, target.breadcrumb, "cli", options.version !== undefined, options.rootUsageName)
-            : renderLeafHelp(target.node, target.breadcrumb, casing, options.rootUsageName);
+            ? renderGroupHelp(target.node, target.breadcrumb, "cli", options.version !== undefined, options.presets === true, options.rootUsageName)
+            : renderLeafHelp(target.node, target.breadcrumb, casing, options.presets === true, options.rootUsageName);
         process.stdout.write(rendered);
     });
 }
-function createNodeCommand(node, casing, execute, pathSegments = []) {
+function createNodeCommand(node, casing, globalLongOptionFlags, execute, presetsEnabled, pathSegments = []) {
     const nextPathSegments = [...pathSegments, node.name];
     if (node.kind === "command") {
         if (!node.scope.includes("cli")) {
             return null;
         }
         const command = new CommanderCommand(node.name);
-        const collected = collectFields(node.params, casing);
+        const collected = collectFields(node.params, casing, globalLongOptionFlags);
         const fields = assignPositionals(collected.fields, node.positional);
         if (node.description !== undefined) {
             command.description(node.description);
         }
         node.aliases.forEach((alias) => command.alias(alias));
         command.addHelpCommand(false);
-        addGlobalOptions(command);
+        addGlobalOptions(command, presetsEnabled);
         command.allowExcessArguments(true);
         if (collected.dynamicFields.length > 0) {
             command.allowUnknownOption(true);
@@ -849,7 +862,7 @@ function createNodeCommand(node, casing, execute, pathSegments = []) {
                 command.argument(formatPositionalToken(field));
                 continue;
             }
-            for (const option of createOption(field)) {
+            for (const option of createOption(field, globalLongOptionFlags)) {
                 command.addOption(option);
             }
         }
@@ -863,6 +876,7 @@ function createNodeCommand(node, casing, execute, pathSegments = []) {
                 dynamicFields: collected.dynamicFields,
                 fields,
                 positionalValues,
+                presetsEnabled,
                 rawArgv: actionCommand.args,
                 actionCommand,
                 variants: collected.variants,
@@ -874,7 +888,7 @@ function createNodeCommand(node, casing, execute, pathSegments = []) {
         return null;
     }
     const visibleChildren = node.children
-        .map((child) => createNodeCommand(child, casing, execute, nextPathSegments))
+        .map((child) => createNodeCommand(child, casing, globalLongOptionFlags, execute, presetsEnabled, nextPathSegments))
         .filter((child) => child !== null);
     const group = new CommanderCommand(node.name);
     if (node.description !== undefined) {
@@ -882,7 +896,7 @@ function createNodeCommand(node, casing, execute, pathSegments = []) {
     }
     node.aliases.forEach((alias) => group.alias(alias));
     group.addHelpCommand(false);
-    addGlobalOptions(group);
+    addGlobalOptions(group, presetsEnabled);
     for (const child of visibleChildren) {
         const isDefaultChild = node.default !== undefined &&
             node.default.scope.includes("cli") &&
@@ -891,9 +905,11 @@ function createNodeCommand(node, casing, execute, pathSegments = []) {
     }
     return group;
 }
-function addGlobalOptions(command) {
+function addGlobalOptions(command, presetsEnabled) {
+    if (presetsEnabled) {
+        command.option("--preset <path>", "Load parameter defaults from a JSON file.");
+    }
     command
-        .option("--preset <path>", "Load parameter defaults from a JSON file.")
         .option("--yes", "Accept defaults and skip prompts.")
         .option("--output <format>", "Output format.", (value) => {
         if (value === "rich" || value === "md" || value === "json") {
@@ -1927,7 +1943,7 @@ async function executeCommand(state, services, requirementOptions, runtimeOption
     };
     await withOutputFormat(output, async () => {
         await assertCommandRequirements(state.command, preflightContext, runtime.requirementOptions);
-        const params = await resolveParams(state.fields, state.dynamicFields, state.variants, state.positionalValues, optionValues, state.rawArgv, state.casing, resolvedFlags.preset, shouldPrompt);
+        const params = await resolveParams(state.fields, state.dynamicFields, state.variants, state.positionalValues, optionValues, state.rawArgv, state.casing, state.presetsEnabled ? resolvedFlags.preset : undefined, shouldPrompt);
         const context = {
             ...preflightContext,
             params,
@@ -2010,7 +2026,9 @@ export async function runCLI(roots, options = {}) {
     program.exitOverride();
     program.showHelpAfterError();
     program.addHelpCommand(false);
-    addGlobalOptions(program);
+    const presetsEnabled = options.presets === true;
+    const globalLongOptionFlags = getGlobalLongOptionFlags(presetsEnabled);
+    addGlobalOptions(program, presetsEnabled);
     if (version !== undefined) {
         program.version(version, "--version");
     }
@@ -2020,7 +2038,7 @@ export async function runCLI(roots, options = {}) {
         await executeCommand(state, servicesWithBuiltIns, requirementOptions, runtimeOptions);
     };
     for (const child of root.children) {
-        const command = createNodeCommand(child, casing, execute);
+        const command = createNodeCommand(child, casing, globalLongOptionFlags, execute, presetsEnabled);
         if (command === null) {
             continue;
         }

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

@@ -0,0 +1,2 @@
+import type { AgentDefinition } from "../types.js";
+export declare const claudeCodeAgent: AgentDefinition;

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

@@ -0,0 +1,15 @@
+export const claudeCodeAgent = {
+    id: "claude-code",
+    name: "claude-code",
+    label: "Claude Code",
+    summary: "Configure Claude Code to route through Poe.",
+    aliases: ["claude"],
+    binaryName: "claude",
+    configPath: "~/.claude/settings.json",
+    branding: {
+        colors: {
+            dark: "#C15F3C",
+            light: "#C15F3C"
+        }
+    }
+};

package/node_modules/@poe-code/agent-defs/dist/agents/claude-desktop.d.ts

@@ -0,0 +1,2 @@
+import type { AgentDefinition } from "../types.js";
+export declare const claudeDesktopAgent: AgentDefinition;

package/node_modules/@poe-code/agent-defs/dist/agents/claude-desktop.js

@@ -0,0 +1,13 @@
+export const claudeDesktopAgent = {
+    id: "claude-desktop",
+    name: "claude-desktop",
+    label: "Claude Desktop",
+    summary: "Anthropic's official desktop application for Claude",
+    configPath: "~/.claude/settings.json",
+    branding: {
+        colors: {
+            dark: "#D97757",
+            light: "#D97757"
+        }
+    }
+};

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

@@ -0,0 +1,2 @@
+import type { AgentDefinition } from "../types.js";
+export declare const codexAgent: AgentDefinition;

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

@@ -0,0 +1,14 @@
+export const codexAgent = {
+    id: "codex",
+    name: "codex",
+    label: "Codex",
+    summary: "Configure Codex to use Poe as the model provider.",
+    binaryName: "codex",
+    configPath: "~/.codex/config.toml",
+    branding: {
+        colors: {
+            dark: "#D5D9DF",
+            light: "#7A7F86"
+        }
+    }
+};

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

@@ -0,0 +1,2 @@
+import type { AgentDefinition } from "../types.js";
+export declare const gooseAgent: AgentDefinition;

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

@@ -0,0 +1,14 @@
+export const gooseAgent = {
+    id: "goose",
+    name: "goose",
+    label: "Goose",
+    summary: "Block's open-source AI agent with ACP support.",
+    binaryName: "goose",
+    configPath: "~/.config/goose/config.yaml",
+    branding: {
+        colors: {
+            dark: "#FF6B35",
+            light: "#E85D26"
+        }
+    }
+};

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

@@ -0,0 +1,7 @@
+export { claudeCodeAgent } from "./claude-code.js";
+export { claudeDesktopAgent } from "./claude-desktop.js";
+export { codexAgent } from "./codex.js";
+export { openCodeAgent } from "./opencode.js";
+export { kimiAgent } from "./kimi.js";
+export { gooseAgent } from "./goose.js";
+export { poeAgentAgent } from "./poe-agent.js";

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

@@ -0,0 +1,7 @@
+export { claudeCodeAgent } from "./claude-code.js";
+export { claudeDesktopAgent } from "./claude-desktop.js";
+export { codexAgent } from "./codex.js";
+export { openCodeAgent } from "./opencode.js";
+export { kimiAgent } from "./kimi.js";
+export { gooseAgent } from "./goose.js";
+export { poeAgentAgent } from "./poe-agent.js";

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

@@ -0,0 +1,2 @@
+import type { AgentDefinition } from "../types.js";
+export declare const kimiAgent: AgentDefinition;

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

@@ -0,0 +1,15 @@
+export const kimiAgent = {
+    id: "kimi",
+    name: "kimi",
+    label: "Kimi",
+    summary: "Configure Kimi CLI to use Poe API",
+    aliases: ["kimi-cli"],
+    binaryName: "kimi",
+    configPath: "~/.kimi/config.toml",
+    branding: {
+        colors: {
+            dark: "#7B68EE",
+            light: "#6A5ACD"
+        }
+    }
+};

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

@@ -0,0 +1,2 @@
+import type { AgentDefinition } from "../types.js";
+export declare const openCodeAgent: AgentDefinition;

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

@@ -0,0 +1,14 @@
+export const openCodeAgent = {
+    id: "opencode",
+    name: "opencode",
+    label: "OpenCode CLI",
+    summary: "Configure OpenCode CLI to use the Poe API.",
+    binaryName: "opencode",
+    configPath: "~/.config/opencode/config.json",
+    branding: {
+        colors: {
+            dark: "#4A4F55",
+            light: "#2F3338"
+        }
+    }
+};

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

@@ -0,0 +1,2 @@
+import type { AgentDefinition } from "../types.js";
+export declare const poeAgentAgent: AgentDefinition;

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

@@ -0,0 +1,13 @@
+export const poeAgentAgent = {
+    id: "poe-agent",
+    name: "poe-agent",
+    label: "Poe Agent",
+    summary: "Run one-shot prompts with the built-in Poe agent runtime.",
+    configPath: "~/.poe-code/config.json",
+    branding: {
+        colors: {
+            dark: "#A465F7",
+            light: "#7A3FD3"
+        }
+    }
+};

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

@@ -0,0 +1,5 @@
+export type { AgentDefinition } from "./types.js";
+export type { AgentSpecifier } from "./specifier.js";
+export { claudeCodeAgent, claudeDesktopAgent, codexAgent, openCodeAgent, kimiAgent, gooseAgent, poeAgentAgent } from "./agents/index.js";
+export { allAgents, resolveAgentId } from "./registry.js";
+export { parseAgentSpecifier, formatAgentSpecifier, normalizeAgentId } from "./specifier.js";

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

@@ -0,0 +1,3 @@
+export { claudeCodeAgent, claudeDesktopAgent, codexAgent, openCodeAgent, kimiAgent, gooseAgent, poeAgentAgent } from "./agents/index.js";
+export { allAgents, resolveAgentId } from "./registry.js";
+export { parseAgentSpecifier, formatAgentSpecifier, normalizeAgentId } from "./specifier.js";

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

@@ -0,0 +1,3 @@
+import type { AgentDefinition } from "./types.js";
+export declare const allAgents: AgentDefinition[];
+export declare function resolveAgentId(input: string): string | undefined;

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

@@ -0,0 +1,26 @@
+import { claudeCodeAgent, claudeDesktopAgent, codexAgent, openCodeAgent, kimiAgent, gooseAgent, poeAgentAgent } from "./agents/index.js";
+export const allAgents = [
+    claudeCodeAgent,
+    claudeDesktopAgent,
+    codexAgent,
+    openCodeAgent,
+    kimiAgent,
+    gooseAgent,
+    poeAgentAgent
+];
+const lookup = new Map();
+for (const agent of allAgents) {
+    const values = [agent.id, agent.name, ...(agent.aliases ?? [])];
+    for (const value of values) {
+        const normalized = value.toLowerCase();
+        if (!lookup.has(normalized)) {
+            lookup.set(normalized, agent.id);
+        }
+    }
+}
+export function resolveAgentId(input) {
+    if (!input) {
+        return undefined;
+    }
+    return lookup.get(input.toLowerCase());
+}

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

@@ -0,0 +1,7 @@
+export interface AgentSpecifier {
+    agent: string;
+    model?: string;
+}
+export declare function parseAgentSpecifier(input: string): AgentSpecifier;
+export declare function formatAgentSpecifier(specifier: AgentSpecifier): string;
+export declare function normalizeAgentId(input: string): string;

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

@@ -0,0 +1,27 @@
+import { resolveAgentId } from "./registry.js";
+export function parseAgentSpecifier(input) {
+    const colonIndex = input.indexOf(":");
+    if (colonIndex === -1) {
+        return { agent: input.trim() };
+    }
+    const agent = input.slice(0, colonIndex).trim();
+    const model = input.slice(colonIndex + 1).trim();
+    return {
+        agent,
+        ...(model.length > 0 ? { model } : {}),
+    };
+}
+export function formatAgentSpecifier(specifier) {
+    if (specifier.model) {
+        return `${specifier.agent}:${specifier.model}`;
+    }
+    return specifier.agent;
+}
+export function normalizeAgentId(input) {
+    const specifier = parseAgentSpecifier(input.trim());
+    const agent = resolveAgentId(specifier.agent) ?? specifier.agent;
+    return formatAgentSpecifier({
+        agent,
+        model: specifier.model
+    });
+}

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

@@ -0,0 +1,16 @@
+export interface AgentDefinition {
+    id: string;
+    name: string;
+    label: string;
+    summary: string;
+    aliases?: string[];
+    /** Binary name for CLI agents. Optional for GUI-only apps like Claude Desktop. */
+    binaryName?: string;
+    configPath: string;
+    branding: {
+        colors: {
+            dark: string;
+            light: string;
+        };
+    };
+}

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

@@ -0,0 +1 @@
+export {};

package/node_modules/@poe-code/agent-defs/package.json

@@ -0,0 +1,20 @@
+{
+  "name": "@poe-code/agent-defs",
+  "version": "0.0.1",
+  "private": true,
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "scripts": {
+    "build": "tsc"
+  },
+  "files": [
+    "dist"
+  ]
+}

package/node_modules/@poe-code/config-mutations/dist/execution/apply-mutation.d.ts

@@ -0,0 +1,5 @@
+import type { Mutation, MutationContext, MutationOutcome, MutationDetails, MutationOptions } from "../types.js";
+export declare function applyMutation(mutation: Mutation, context: MutationContext, options: MutationOptions): Promise<{
+    outcome: MutationOutcome;
+    details: MutationDetails;
+}>;