toolcraft 0.0.2 → 0.0.3

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/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>;