toolcraft 0.0.1 → 0.0.3

package/node_modules/@poe-code/agent-mcp-config/dist/apply.js

@@ -0,0 +1,175 @@
+import path from "node:path";
+import { parse as parseYaml, stringify as stringifyYaml } from "yaml";
+import { runMutations, configMutation, fileMutation, readFileIfExists } from "@poe-code/config-mutations";
+import { getAgentConfig, resolveConfigPath, isSupported } from "./configs.js";
+import { getShapeTransformer } from "./shapes.js";
+function getConfigDirectory(configPath) {
+    return path.dirname(configPath);
+}
+export class UnsupportedAgentError extends Error {
+    constructor(agentId) {
+        super(`Unsupported agent: ${agentId}`);
+        this.name = "UnsupportedAgentError";
+    }
+}
+function isConfigObject(value) {
+    return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function resolveServerMap(document, configKey) {
+    const value = document[configKey];
+    return isConfigObject(value) ? value : {};
+}
+function mergeServerMap(document, configKey, servers) {
+    return { ...document, [configKey]: servers };
+}
+function expandHomePath(configPath, homeDir) {
+    if (!configPath.startsWith("~")) {
+        return configPath;
+    }
+    if (configPath === "~") {
+        return homeDir;
+    }
+    if (configPath.startsWith("~/")) {
+        return path.join(homeDir, configPath.slice(2));
+    }
+    return path.join(homeDir, configPath.slice(1));
+}
+function parseYamlDocument(content) {
+    if (content.trim() === "") {
+        return {};
+    }
+    const parsed = parseYaml(content);
+    if (parsed === null || parsed === undefined) {
+        return {};
+    }
+    if (!isConfigObject(parsed)) {
+        throw new Error("Expected YAML document to be an object.");
+    }
+    return parsed;
+}
+function serializeYamlDocument(document) {
+    const serialized = stringifyYaml(document);
+    return serialized.endsWith("\n") ? serialized : `${serialized}\n`;
+}
+async function readYamlConfig(configPath, options) {
+    const absolutePath = expandHomePath(configPath, options.homeDir);
+    const existingContent = await readFileIfExists(options.fs, absolutePath);
+    if (existingContent === null) {
+        return {};
+    }
+    return parseYamlDocument(existingContent);
+}
+async function writeYamlConfig(configPath, document, options) {
+    if (options.dryRun) {
+        return;
+    }
+    const absolutePath = expandHomePath(configPath, options.homeDir);
+    const configDir = path.dirname(absolutePath);
+    await options.fs.mkdir(configDir, { recursive: true });
+    await options.fs.writeFile(absolutePath, serializeYamlDocument(document), {
+        encoding: "utf8"
+    });
+}
+function removeServer(document, configKey, serverName) {
+    const servers = resolveServerMap(document, configKey);
+    if (!(serverName in servers)) {
+        return { changed: false, content: document };
+    }
+    const nextServers = { ...servers };
+    delete nextServers[serverName];
+    if (Object.keys(nextServers).length === 0) {
+        const nextDocument = { ...document };
+        delete nextDocument[configKey];
+        return { changed: true, content: nextDocument };
+    }
+    return {
+        changed: true,
+        content: mergeServerMap(document, configKey, nextServers)
+    };
+}
+export async function configure(agentId, server, options) {
+    if (!isSupported(agentId)) {
+        throw new UnsupportedAgentError(agentId);
+    }
+    const config = getAgentConfig(agentId);
+    const configPath = resolveConfigPath(config, options.platform);
+    const shapeTransformer = getShapeTransformer(config.shape);
+    const shaped = shapeTransformer(server);
+    if (shaped === undefined) {
+        await unconfigure(agentId, server.name, options);
+        return;
+    }
+    if (config.format === "yaml") {
+        const document = await readYamlConfig(configPath, options);
+        const servers = resolveServerMap(document, config.configKey);
+        const nextDocument = mergeServerMap(document, config.configKey, {
+            ...servers,
+            [server.name]: shaped
+        });
+        await writeYamlConfig(configPath, nextDocument, options);
+        return;
+    }
+    const configDir = getConfigDirectory(configPath);
+    await runMutations([
+        fileMutation.ensureDirectory({
+            path: configDir,
+            label: `Ensure directory ${configDir}`
+        }),
+        // Use transform to replace the server entry entirely (not deep-merge)
+        // This ensures old fields like 'args' are removed when switching to array 'command'
+        configMutation.transform({
+            target: configPath,
+            format: config.format,
+            transform: (document) => {
+                const servers = resolveServerMap(document, config.configKey);
+                const newServers = {
+                    ...servers,
+                    [server.name]: shaped
+                };
+                return {
+                    changed: true,
+                    content: mergeServerMap(document, config.configKey, newServers)
+                };
+            },
+            label: `Add ${server.name} to ${configPath}`
+        })
+    ], {
+        fs: options.fs,
+        homeDir: options.homeDir,
+        dryRun: options.dryRun,
+        observers: options.observers
+    });
+}
+export async function unconfigure(agentId, serverName, options) {
+    if (!isSupported(agentId)) {
+        throw new UnsupportedAgentError(agentId);
+    }
+    const config = getAgentConfig(agentId);
+    const configPath = resolveConfigPath(config, options.platform);
+    if (config.format === "yaml") {
+        const document = await readYamlConfig(configPath, options);
+        const { changed, content } = removeServer(document, config.configKey, serverName);
+        if (!changed) {
+            return;
+        }
+        await writeYamlConfig(configPath, content, options);
+        return;
+    }
+    await runMutations([
+        configMutation.prune({
+            target: configPath,
+            format: config.format,
+            shape: {
+                [config.configKey]: {
+                    [serverName]: {}
+                }
+            },
+            label: `Remove ${serverName} from ${configPath}`
+        })
+    ], {
+        fs: options.fs,
+        homeDir: options.homeDir,
+        dryRun: options.dryRun,
+        observers: options.observers
+    });
+}

package/node_modules/@poe-code/agent-mcp-config/dist/configs.d.ts

@@ -0,0 +1,22 @@
+import type { ShapeName } from "./shapes.js";
+export type ConfigFormat = "json" | "toml" | "yaml";
+export type Platform = "darwin" | "linux" | "win32";
+export interface AgentMcpConfig {
+    configFile: string | ((platform: Platform) => string);
+    configKey: string;
+    format: ConfigFormat;
+    shape: ShapeName;
+    mcpOutputFormat?: string;
+}
+export declare const supportedAgents: readonly string[];
+export type AgentSupportStatus = "supported" | "unsupported" | "unknown";
+export interface AgentSupportResult {
+    status: AgentSupportStatus;
+    input: string;
+    id?: string;
+    config?: AgentMcpConfig;
+}
+export declare function resolveAgentSupport(input: string, registry?: Record<string, AgentMcpConfig>): AgentSupportResult;
+export declare function isSupported(agentId: string): boolean;
+export declare function getAgentConfig(agentId: string): AgentMcpConfig | undefined;
+export declare function resolveConfigPath(config: AgentMcpConfig, platform: Platform): string;

package/node_modules/@poe-code/agent-mcp-config/dist/configs.js

@@ -0,0 +1,74 @@
+import { resolveAgentId } from "@poe-code/agent-defs";
+const agentMcpConfigs = {
+    "claude-code": {
+        configFile: "~/.claude.json",
+        configKey: "mcpServers",
+        format: "json",
+        shape: "standard"
+    },
+    "claude-desktop": {
+        configFile: (platform) => {
+            switch (platform) {
+                case "darwin":
+                    return "~/Library/Application Support/Claude/claude_desktop_config.json";
+                case "win32":
+                    return "~/AppData/Roaming/Claude/claude_desktop_config.json";
+                default:
+                    return "~/.config/Claude/claude_desktop_config.json";
+            }
+        },
+        configKey: "mcpServers",
+        format: "json",
+        shape: "standard",
+        mcpOutputFormat: "markdown_instructions"
+    },
+    codex: {
+        configFile: "~/.codex/config.toml",
+        configKey: "mcp_servers",
+        format: "toml",
+        shape: "standard"
+    },
+    opencode: {
+        configFile: "~/.config/opencode/opencode.json",
+        configKey: "mcp",
+        format: "json",
+        shape: "opencode"
+    },
+    kimi: {
+        configFile: "~/.kimi/mcp.json",
+        configKey: "mcpServers",
+        format: "json",
+        shape: "standard"
+    },
+    goose: {
+        configFile: "~/.config/goose/config.yaml",
+        configKey: "extensions",
+        format: "yaml",
+        shape: "goose"
+    }
+};
+export const supportedAgents = Object.keys(agentMcpConfigs);
+export function resolveAgentSupport(input, registry = agentMcpConfigs) {
+    const resolvedId = resolveAgentId(input);
+    if (!resolvedId) {
+        return { status: "unknown", input };
+    }
+    const config = registry[resolvedId];
+    if (!config) {
+        return { status: "unsupported", input, id: resolvedId };
+    }
+    return { status: "supported", input, id: resolvedId, config };
+}
+export function isSupported(agentId) {
+    return resolveAgentSupport(agentId).status === "supported";
+}
+export function getAgentConfig(agentId) {
+    const support = resolveAgentSupport(agentId);
+    return support.status === "supported" ? support.config : undefined;
+}
+export function resolveConfigPath(config, platform) {
+    if (typeof config.configFile === "function") {
+        return config.configFile(platform);
+    }
+    return config.configFile;
+}

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

@@ -0,0 +1,3 @@
+export type { McpStdioServer, McpHttpServer, McpServerConfig, McpServerEntry, ApplyOptions } from "./types.js";
+export { supportedAgents, isSupported, resolveAgentSupport } from "./configs.js";
+export { configure, unconfigure, UnsupportedAgentError } from "./apply.js";

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

@@ -0,0 +1,2 @@
+export { supportedAgents, isSupported, resolveAgentSupport } from "./configs.js";
+export { configure, unconfigure, UnsupportedAgentError } from "./apply.js";

package/node_modules/@poe-code/agent-mcp-config/dist/shapes.d.ts

@@ -0,0 +1,31 @@
+import type { McpServerEntry } from "./types.js";
+export type ShapeName = "standard" | "opencode" | "goose";
+export interface StandardShapeOutput {
+    command: string;
+    args?: string[];
+    env?: Record<string, string>;
+}
+export interface OpencodeShapeOutput {
+    type: "local";
+    command: string[];
+    env?: Record<string, string>;
+    enabled: boolean;
+}
+export interface GooseStdioShapeOutput {
+    type: "stdio";
+    cmd: string;
+    args?: string[];
+    envs?: Record<string, string>;
+}
+export interface GooseHttpShapeOutput {
+    type: "http";
+    url: string;
+    headers?: Record<string, string>;
+}
+export type GooseShapeOutput = GooseStdioShapeOutput | GooseHttpShapeOutput;
+export type ShapeOutput = StandardShapeOutput | OpencodeShapeOutput | GooseShapeOutput;
+export type ShapeTransformer = (entry: McpServerEntry) => ShapeOutput | undefined;
+export declare function standardShape(entry: McpServerEntry): ShapeOutput | undefined;
+export declare function opencodeShape(entry: McpServerEntry): OpencodeShapeOutput;
+export declare function gooseShape(entry: McpServerEntry): GooseShapeOutput | undefined;
+export declare function getShapeTransformer(shape: ShapeName): ShapeTransformer;

package/node_modules/@poe-code/agent-mcp-config/dist/shapes.js

@@ -0,0 +1,87 @@
+function transformStdioServer(config, enabled) {
+    if (!enabled) {
+        return undefined;
+    }
+    const result = {
+        command: config.command
+    };
+    if (config.args && config.args.length > 0) {
+        result.args = config.args;
+    }
+    if (config.env && Object.keys(config.env).length > 0) {
+        result.env = config.env;
+    }
+    return result;
+}
+export function standardShape(entry) {
+    const enabled = entry.enabled !== false;
+    if (entry.config.transport === "stdio") {
+        return transformStdioServer(entry.config, enabled);
+    }
+    if (!enabled) {
+        return undefined;
+    }
+    return {
+        command: entry.config.url
+    };
+}
+function transformStdioServerOpencode(config, enabled) {
+    const command = config.args && config.args.length > 0
+        ? [config.command, ...config.args]
+        : [config.command];
+    const result = {
+        type: "local",
+        command,
+        enabled
+    };
+    if (config.env && Object.keys(config.env).length > 0) {
+        result.env = config.env;
+    }
+    return result;
+}
+export function opencodeShape(entry) {
+    const enabled = entry.enabled !== false;
+    if (entry.config.transport === "stdio") {
+        return transformStdioServerOpencode(entry.config, enabled);
+    }
+    return {
+        type: "local",
+        command: [entry.config.url],
+        enabled
+    };
+}
+export function gooseShape(entry) {
+    const enabled = entry.enabled !== false;
+    if (!enabled) {
+        return undefined;
+    }
+    if (entry.config.transport === "stdio") {
+        const result = {
+            type: "stdio",
+            cmd: entry.config.command
+        };
+        if (entry.config.args && entry.config.args.length > 0) {
+            result.args = entry.config.args;
+        }
+        if (entry.config.env && Object.keys(entry.config.env).length > 0) {
+            result.envs = entry.config.env;
+        }
+        return result;
+    }
+    const result = {
+        type: "http",
+        url: entry.config.url
+    };
+    if (entry.config.headers && Object.keys(entry.config.headers).length > 0) {
+        result.headers = entry.config.headers;
+    }
+    return result;
+}
+const shapeTransformers = {
+    standard: standardShape,
+    opencode: opencodeShape,
+    goose: gooseShape
+};
+export function getShapeTransformer(shape) {
+    return shapeTransformers[shape];
+}

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

@@ -0,0 +1,25 @@
+import type { FileSystem, MutationObservers } from "@poe-code/config-mutations";
+export interface McpStdioServer {
+    transport: "stdio";
+    command: string;
+    args?: string[];
+    env?: Record<string, string>;
+}
+export interface McpHttpServer {
+    transport: "http";
+    url: string;
+    headers?: Record<string, string>;
+}
+export type McpServerConfig = McpStdioServer | McpHttpServer;
+export interface McpServerEntry {
+    name: string;
+    config: McpServerConfig;
+    enabled?: boolean;
+}
+export interface ApplyOptions {
+    fs: FileSystem;
+    homeDir: string;
+    platform: "darwin" | "linux" | "win32";
+    dryRun?: boolean;
+    observers?: MutationObservers;
+}

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

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

package/node_modules/@poe-code/agent-mcp-config/package.json

@@ -0,0 +1,25 @@
+{
+  "name": "@poe-code/agent-mcp-config",
+  "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"
+  ],
+  "dependencies": {
+    "@poe-code/agent-defs": "*",
+    "@poe-code/config-mutations": "*",
+    "yaml": "^2.8.3"
+  }
+}

package/node_modules/@poe-code/design-system/dist/prompts/primitives/cancel.d.ts

@@ -1,2 +1,2 @@
-export { isCancel } from "@clack/core";
+export { isCancel } from "@clack/prompts";
 export declare function cancel(msg?: string): void;

package/node_modules/@poe-code/design-system/dist/prompts/primitives/cancel.js

@@ -1,5 +1,5 @@
 import chalk from "chalk";
-export { isCancel } from "@clack/core";
+export { isCancel } from "@clack/prompts";
 import { resolveOutputFormat } from "../../internal/output-format.js";
 export function cancel(msg = "") {
     if (resolveOutputFormat() !== "terminal") {

package/node_modules/@poe-code/task-list/README.md

@@ -0,0 +1,114 @@
+# @poe-code/task-list
+
+Multi-list task manager with pluggable storage backends.
+
+## Backends
+
+`@poe-code/task-list` exposes one API over two backends:
+
+- `markdown-dir`: one Markdown file per task, organized into subdirectories per list
+- `yaml-file`: one YAML document with a top-level `lists:` mapping
+
+The task lifecycle is `draft -> planned -> in-progress -> done -> archived`. `archived` is terminal.
+
+## Public API
+
+- `openTaskList(options)`: opens a task store and returns a `TaskList`
+- `TaskList`: top-level interface for listing lists, querying all tasks, and resolving qualified IDs
+- `Tasks`: per-list interface for create, update, `fire`, `canFire`, `events`, delete, and list operations
+- `Task`: normalized task record with `list`, `id`, `qualifiedId`, `name`, `state`, `description`, and `metadata`
+- `TaskState`: `"draft" | "planned" | "in-progress" | "done" | "archived"`
+- `TaskDefaults`: default `metadata` applied when creating new tasks
+- `StateMachineDef` / `EventDef`: exported types for custom task lifecycle definitions passed via `openTaskList({ stateMachine })`
+- `defaultStateMachine`: exported default lifecycle with `plan`, `start`, `complete`, and `archive` events
+- Error classes: `TaskNotFoundError`, `TaskAlreadyExistsError`, `InvalidTransitionError`, `MalformedTaskError`
+
+## State Machines
+
+```ts
+interface StateMachineDef<TState extends string = string, TEvent extends string = string> {
+  initial: TState;
+  states: readonly TState[];
+  events: Readonly<Record<TEvent, EventDef<TState>>>;
+}
+
+interface EventDef<TState extends string = string> {
+  from: readonly TState[] | "*";
+  to: TState;
+  guard?: (task: Task) => true | string;
+  onEnter?: (task: Task) => void | Promise<void>;
+  onExit?: (task: Task) => void | Promise<void>;
+}
+```
+
+Pass a custom machine with `openTaskList({ stateMachine })`. If omitted, the package uses `defaultStateMachine`, whose event names are `plan`, `start`, `complete`, and `archive`.
+
+## Options
+
+| Option | Type | Default | Behavior |
+| --- | --- | --- | --- |
+| `type` | `"markdown-dir" \| "yaml-file"` | required | Selects the backend implementation. |
+| `path` | `string` | required | Root directory for `markdown-dir` or YAML file path for `yaml-file`. |
+| `defaults` | `TaskDefaults` | `{ metadata: {} }` | Seeds omitted metadata on new tasks only. New tasks always start at the configured state machine's initial state. |
+| `create` | `boolean` | `false` | Creates missing storage for the selected backend when enabled. |
+| `lockStaleMs` | `number` | `30_000` | Stale threshold passed to backend file locking. |
+| `lockRetries` | `number` | `20` | Retry count passed to backend file locking. |
+| `fs` | `TaskListFs` | `node:fs/promises` adapter | Injectable filesystem, primarily for tests. |
+| `stateMachine` | `StateMachineDef` | `defaultStateMachine` | Overrides the task lifecycle used by `create`, `fire`, `canFire`, and `events`. |
+
+## Env vars
+
+None.
+
+## Usage
+
+### `markdown-dir`
+
+```ts
+import { openTaskList } from "@poe-code/task-list";
+
+const taskList = await openTaskList({
+  type: "markdown-dir",
+  path: "/repo/tasks",
+  create: true
+});
+
+const planning = taskList.list("planning");
+
+await planning.create({
+  id: "ship-readme",
+  name: "Ship package README"
+});
+
+await planning.fire("ship-readme", "plan");
+```
+
+### `yaml-file`
+
+```ts
+import { openTaskList } from "@poe-code/task-list";
+
+const taskList = await openTaskList({
+  type: "yaml-file",
+  path: "/repo/tasks.yaml",
+  create: true
+});
+
+const planning = taskList.list("planning");
+
+await planning.create({
+  id: "review-release",
+  name: "Review release checklist"
+});
+
+await planning.fire("review-release", "plan");
+await planning.fire("review-release", "start");
+```
+
+## Notes
+
+The package never overwrites existing task files or store files. `defaults.metadata` is applied only when creating new tasks and does not retroactively update existing tasks.
+
+Task state changes are event-driven: use `fire(id, event)` to move between states, `canFire(id, event)` to check whether an event is currently legal, and `events(id)` to list the currently legal event names. There is no `transition()` API.
+
+`create()` always starts new tasks at `stateMachine.initial`. `update()` cannot change `state`; use `fire()` instead.

package/node_modules/@poe-code/task-list/dist/backends/markdown-dir.d.ts

@@ -0,0 +1,2 @@
+import { type BackendDeps, type TaskList } from "../types.js";
+export declare function markdownDirBackend(deps: BackendDeps): Promise<TaskList>;