poe-code 3.0.196 → 3.0.198

package/packages/memory/dist/query.js

@@ -1,6 +1,6 @@
 import * as fs from "node:fs/promises";
 import path from "node:path";
-import { countTokens } from "tokenfill";
+import { countTokens } from "../../tokenfill/dist/index.js";
 import { spawn } from "@poe-code/agent-spawn";
 import { resolveAgent } from "@poe-code/poe-code-config";
 import { listPages } from "./pages.js";

package/packages/memory/dist/tokens.js

@@ -1,6 +1,6 @@
 import * as fs from "node:fs/promises";
 import path from "node:path";
-import { countTokens } from "tokenfill";
+import { countTokens } from "../../tokenfill/dist/index.js";
 import { listPages } from "./pages.js";
 export async function computeTokenStats(root) {
     if (!(await pathExists(root))) {

package/packages/superintendent/dist/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export declare function main(argv?: string[]): Promise<void>;

package/packages/superintendent/dist/cli.js

@@ -0,0 +1,41 @@
+#!/usr/bin/env node
+import { runCLI } from "toolcraft/cli";
+import { isDirectExecution } from "./direct-execution.js";
+import { superintendentGroup } from "./commands/index.js";
+function normalizeArgv(argv) {
+    const normalized = normalizeMarkdownOutput(argv);
+    if (normalized.length <= 2) {
+        return [...normalized, "--help"];
+    }
+    return normalized;
+}
+function normalizeMarkdownOutput(argv) {
+    const normalized = [];
+    for (let index = 0; index < argv.length; index += 1) {
+        const argument = argv[index] ?? "";
+        if (argument === "--output" && argv[index + 1] === "markdown") {
+            normalized.push(argument, "md");
+            index += 1;
+            continue;
+        }
+        if (argument === "--output=markdown") {
+            normalized.push("--output=md");
+            continue;
+        }
+        normalized.push(argument);
+    }
+    return normalized;
+}
+export async function main(argv = process.argv) {
+    const originalArgv = process.argv;
+    process.argv = normalizeArgv(argv);
+    try {
+        await runCLI(superintendentGroup);
+    }
+    finally {
+        process.argv = originalArgv;
+    }
+}
+if (await isDirectExecution(import.meta.url, process.argv)) {
+    await main();
+}

package/packages/superintendent/dist/commands/builder-group.d.ts

@@ -0,0 +1,52 @@
+import { runBuilder, type BuilderResult } from "../runtime/run-builder.js";
+export type BuilderGroupRunners = {
+    runBuilder?: typeof runBuilder;
+};
+export declare function createBuilderRunCommand(runners?: BuilderGroupRunners): import("toolcraft").Command<{
+    [x: string]: never;
+}, import("toolcraft-schema").ObjectSchema<{
+    readonly path: import("toolcraft-schema").StringSchema;
+}>, undefined, BuilderResult> & {
+    readonly __agentKitCommandTypeInfo: import("toolcraft").CommandTypeInfo<"run", import("toolcraft-schema").ObjectSchema<{
+        readonly path: import("toolcraft-schema").StringSchema;
+    }>, BuilderResult, ("mcp" | "cli" | "sdk")[], undefined>;
+};
+export declare const builderRunCommand: import("toolcraft").Command<{
+    [x: string]: never;
+}, import("toolcraft-schema").ObjectSchema<{
+    readonly path: import("toolcraft-schema").StringSchema;
+}>, undefined, BuilderResult> & {
+    readonly __agentKitCommandTypeInfo: import("toolcraft").CommandTypeInfo<"run", import("toolcraft-schema").ObjectSchema<{
+        readonly path: import("toolcraft-schema").StringSchema;
+    }>, BuilderResult, ("mcp" | "cli" | "sdk")[], undefined>;
+};
+export declare function createBuilderGroup(runners?: BuilderGroupRunners): import("toolcraft").Group<{
+    [x: string]: never;
+}> & {
+    readonly __agentKitGroupTypeInfo: import("toolcraft").GroupTypeInfo<{
+        [x: string]: never;
+    }, "builder", (import("toolcraft").Command<{
+        [x: string]: never;
+    }, import("toolcraft-schema").ObjectSchema<{
+        readonly path: import("toolcraft-schema").StringSchema;
+    }>, undefined, BuilderResult> & {
+        readonly __agentKitCommandTypeInfo: import("toolcraft").CommandTypeInfo<"run", import("toolcraft-schema").ObjectSchema<{
+            readonly path: import("toolcraft-schema").StringSchema;
+        }>, BuilderResult, ("mcp" | "cli" | "sdk")[], undefined>;
+    })[], ("mcp" | "cli" | "sdk")[], undefined>;
+};
+export declare const builderGroup: import("toolcraft").Group<{
+    [x: string]: never;
+}> & {
+    readonly __agentKitGroupTypeInfo: import("toolcraft").GroupTypeInfo<{
+        [x: string]: never;
+    }, "builder", (import("toolcraft").Command<{
+        [x: string]: never;
+    }, import("toolcraft-schema").ObjectSchema<{
+        readonly path: import("toolcraft-schema").StringSchema;
+    }>, undefined, BuilderResult> & {
+        readonly __agentKitCommandTypeInfo: import("toolcraft").CommandTypeInfo<"run", import("toolcraft-schema").ObjectSchema<{
+            readonly path: import("toolcraft-schema").StringSchema;
+        }>, BuilderResult, ("mcp" | "cli" | "sdk")[], undefined>;
+    })[], ("mcp" | "cli" | "sdk")[], undefined>;
+};

package/packages/superintendent/dist/commands/builder-group.js

@@ -0,0 +1,73 @@
+import { S, UserError, defineCommand, defineGroup } from "toolcraft";
+import { text } from "@poe-code/design-system";
+import { parseSuperintendentDoc } from "../document/parse.js";
+import { runBuilder } from "../runtime/run-builder.js";
+const builderRunParams = S.Object({
+    path: S.String({ description: "Path to the superintendent markdown document" })
+});
+export function createBuilderRunCommand(runners) {
+    const runBuilderImpl = runners?.runBuilder ?? runBuilder;
+    return defineCommand({
+        name: "run",
+        description: "Run the configured builder agent.",
+        positional: ["path"],
+        params: builderRunParams,
+        scope: ["cli", "mcp", "sdk"],
+        handler: async ({ params, fs }) => {
+            const content = await readDocument(params.path, fs);
+            const document = parseSuperintendentDoc(params.path, content);
+            return runBuilderImpl(document, {}, { defaultCwd: process.cwd() });
+        },
+        render: {
+            rich: (result, { logger }) => {
+                logger.success("Builder run completed.");
+                logger.message(text.section("Summary:"));
+                logger.message(result.summary);
+                logger.message(text.section("Log:"));
+                logger.message(result.log || "(no output)");
+            },
+            markdown: (result) => renderBuilderMarkdown(result),
+            json: (result) => result
+        }
+    });
+}
+export const builderRunCommand = createBuilderRunCommand();
+export function createBuilderGroup(runners) {
+    return defineGroup({
+        name: "builder",
+        description: "Builder commands.",
+        scope: ["cli", "mcp", "sdk"],
+        children: [createBuilderRunCommand(runners)]
+    });
+}
+export const builderGroup = createBuilderGroup();
+async function readDocument(filePath, fs) {
+    try {
+        return await fs.readFile(filePath, "utf8");
+    }
+    catch (error) {
+        if (hasCode(error, "ENOENT")) {
+            throw new UserError(`Superintendent document not found: ${filePath}`);
+        }
+        throw error;
+    }
+}
+function renderBuilderMarkdown(result) {
+    const lines = [
+        "## Builder result",
+        "",
+        "### Summary",
+        "",
+        result.summary,
+        "",
+        "### Log",
+        "",
+        "```text",
+        result.log,
+        "```"
+    ];
+    return lines.join("\n");
+}
+function hasCode(error, code) {
+    return typeof error === "object" && error !== null && "code" in error && error.code === code;
+}

package/packages/superintendent/dist/commands/complete.d.ts

@@ -0,0 +1,19 @@
+export declare const completeCommand: import("toolcraft").Command<{
+    [x: string]: never;
+}, import("toolcraft-schema").ObjectSchema<{
+    readonly path: import("toolcraft-schema").StringSchema;
+    readonly reason: import("toolcraft-schema").OptionalSchema<import("toolcraft-schema").StringSchema>;
+}>, undefined, {
+    path: string;
+    state: "completed";
+    reason: string | undefined;
+}> & {
+    readonly __agentKitCommandTypeInfo: import("toolcraft").CommandTypeInfo<"complete", import("toolcraft-schema").ObjectSchema<{
+        readonly path: import("toolcraft-schema").StringSchema;
+        readonly reason: import("toolcraft-schema").OptionalSchema<import("toolcraft-schema").StringSchema>;
+    }>, {
+        path: string;
+        state: "completed";
+        reason: string | undefined;
+    }, ("mcp" | "cli" | "sdk")[], undefined>;
+};

package/packages/superintendent/dist/commands/complete.js

@@ -0,0 +1,54 @@
+import { S, UserError, defineCommand } from "toolcraft";
+import { setStatusReason, transitionState } from "../document/write.js";
+const completeParams = S.Object({
+    path: S.String({ description: "Path to the superintendent markdown document" }),
+    reason: S.Optional(S.String({ description: "Why the loop was force-completed" }))
+});
+export const completeCommand = defineCommand({
+    name: "complete",
+    description: "Manually mark the superintendent loop as completed.",
+    positional: ["path"],
+    params: completeParams,
+    scope: ["cli", "mcp", "sdk"],
+    handler: async ({ params, fs }) => {
+        const content = await readDocument(params.path, fs);
+        const completedContent = transitionState(params.path, content, "completed");
+        const updatedContent = setStatusReason(params.path, completedContent, params.reason);
+        await fs.writeFile(params.path, updatedContent);
+        return {
+            path: params.path,
+            state: "completed",
+            reason: params.reason
+        };
+    },
+    render: {
+        rich: (result, { logger }) => {
+            logger.success(`Marked ${result.path} as completed.`);
+            if (result.reason !== undefined) {
+                logger.message(`Reason: ${result.reason}`);
+            }
+        },
+        markdown: (result) => [
+            "## Superintendent completion",
+            "",
+            `- Path: ${result.path}`,
+            `- State: ${result.state}`,
+            ...(result.reason === undefined ? [] : [`- Reason: ${result.reason}`])
+        ].join("\n"),
+        json: (result) => result
+    }
+});
+async function readDocument(filePath, fs) {
+    try {
+        return await fs.readFile(filePath, "utf8");
+    }
+    catch (error) {
+        if (hasCode(error, "ENOENT")) {
+            throw new UserError(`Superintendent document not found: ${filePath}`);
+        }
+        throw error;
+    }
+}
+function hasCode(error, code) {
+    return typeof error === "object" && error !== null && "code" in error && error.code === code;
+}

package/packages/superintendent/dist/commands/index.d.ts

@@ -0,0 +1,4 @@
+export { builderGroup } from "./builder-group.js";
+export { installCommand } from "./install.js";
+export { inspectorGroup } from "./inspector-group.js";
+export { superintendentGroup, superintendentMcpGroup, createSuperintendentMcpGroup, type SuperintendentMcpGroupRunners } from "./superintendent-group.js";

package/packages/superintendent/dist/commands/index.js

@@ -0,0 +1,4 @@
+export { builderGroup } from "./builder-group.js";
+export { installCommand } from "./install.js";
+export { inspectorGroup } from "./inspector-group.js";
+export { superintendentGroup, superintendentMcpGroup, createSuperintendentMcpGroup } from "./superintendent-group.js";

package/packages/superintendent/dist/commands/inspector-group.d.ts

@@ -0,0 +1,115 @@
+import { runAllInspectors, runInspector, type InspectorResult } from "../runtime/run-inspector.js";
+export type InspectorListItem = {
+    name: string;
+    agent: string;
+    mode?: string;
+};
+export type InspectorGroupRunners = {
+    runInspector?: typeof runInspector;
+    runAllInspectors?: typeof runAllInspectors;
+};
+export declare const inspectorListCommand: import("toolcraft").Command<{
+    [x: string]: never;
+}, import("toolcraft-schema").ObjectSchema<{
+    readonly path: import("toolcraft-schema").StringSchema;
+}>, undefined, {
+    name: string;
+    agent: string;
+    mode: string | undefined;
+}[]> & {
+    readonly __agentKitCommandTypeInfo: import("toolcraft").CommandTypeInfo<"list", import("toolcraft-schema").ObjectSchema<{
+        readonly path: import("toolcraft-schema").StringSchema;
+    }>, {
+        name: string;
+        agent: string;
+        mode: string | undefined;
+    }[], ("mcp" | "cli" | "sdk")[], undefined>;
+};
+export declare function createInspectorRunCommand(runners?: InspectorGroupRunners): import("toolcraft").Command<{
+    [x: string]: never;
+}, import("toolcraft-schema").ObjectSchema<{
+    readonly path: import("toolcraft-schema").StringSchema;
+    readonly name: import("toolcraft-schema").OptionalSchema<import("toolcraft-schema").StringSchema>;
+}>, undefined, InspectorResult[]> & {
+    readonly __agentKitCommandTypeInfo: import("toolcraft").CommandTypeInfo<"run", import("toolcraft-schema").ObjectSchema<{
+        readonly path: import("toolcraft-schema").StringSchema;
+        readonly name: import("toolcraft-schema").OptionalSchema<import("toolcraft-schema").StringSchema>;
+    }>, InspectorResult[], ("mcp" | "cli" | "sdk")[], undefined>;
+};
+export declare const inspectorRunCommand: import("toolcraft").Command<{
+    [x: string]: never;
+}, import("toolcraft-schema").ObjectSchema<{
+    readonly path: import("toolcraft-schema").StringSchema;
+    readonly name: import("toolcraft-schema").OptionalSchema<import("toolcraft-schema").StringSchema>;
+}>, undefined, InspectorResult[]> & {
+    readonly __agentKitCommandTypeInfo: import("toolcraft").CommandTypeInfo<"run", import("toolcraft-schema").ObjectSchema<{
+        readonly path: import("toolcraft-schema").StringSchema;
+        readonly name: import("toolcraft-schema").OptionalSchema<import("toolcraft-schema").StringSchema>;
+    }>, InspectorResult[], ("mcp" | "cli" | "sdk")[], undefined>;
+};
+export declare function createInspectorGroup(runners?: InspectorGroupRunners): import("toolcraft").Group<{
+    [x: string]: never;
+}> & {
+    readonly __agentKitGroupTypeInfo: import("toolcraft").GroupTypeInfo<{
+        [x: string]: never;
+    }, "inspector", ((import("toolcraft").Command<{
+        [x: string]: never;
+    }, import("toolcraft-schema").ObjectSchema<{
+        readonly path: import("toolcraft-schema").StringSchema;
+    }>, undefined, {
+        name: string;
+        agent: string;
+        mode: string | undefined;
+    }[]> & {
+        readonly __agentKitCommandTypeInfo: import("toolcraft").CommandTypeInfo<"list", import("toolcraft-schema").ObjectSchema<{
+            readonly path: import("toolcraft-schema").StringSchema;
+        }>, {
+            name: string;
+            agent: string;
+            mode: string | undefined;
+        }[], ("mcp" | "cli" | "sdk")[], undefined>;
+    }) | (import("toolcraft").Command<{
+        [x: string]: never;
+    }, import("toolcraft-schema").ObjectSchema<{
+        readonly path: import("toolcraft-schema").StringSchema;
+        readonly name: import("toolcraft-schema").OptionalSchema<import("toolcraft-schema").StringSchema>;
+    }>, undefined, InspectorResult[]> & {
+        readonly __agentKitCommandTypeInfo: import("toolcraft").CommandTypeInfo<"run", import("toolcraft-schema").ObjectSchema<{
+            readonly path: import("toolcraft-schema").StringSchema;
+            readonly name: import("toolcraft-schema").OptionalSchema<import("toolcraft-schema").StringSchema>;
+        }>, InspectorResult[], ("mcp" | "cli" | "sdk")[], undefined>;
+    }))[], ("mcp" | "cli" | "sdk")[], undefined>;
+};
+export declare const inspectorGroup: import("toolcraft").Group<{
+    [x: string]: never;
+}> & {
+    readonly __agentKitGroupTypeInfo: import("toolcraft").GroupTypeInfo<{
+        [x: string]: never;
+    }, "inspector", ((import("toolcraft").Command<{
+        [x: string]: never;
+    }, import("toolcraft-schema").ObjectSchema<{
+        readonly path: import("toolcraft-schema").StringSchema;
+    }>, undefined, {
+        name: string;
+        agent: string;
+        mode: string | undefined;
+    }[]> & {
+        readonly __agentKitCommandTypeInfo: import("toolcraft").CommandTypeInfo<"list", import("toolcraft-schema").ObjectSchema<{
+            readonly path: import("toolcraft-schema").StringSchema;
+        }>, {
+            name: string;
+            agent: string;
+            mode: string | undefined;
+        }[], ("mcp" | "cli" | "sdk")[], undefined>;
+    }) | (import("toolcraft").Command<{
+        [x: string]: never;
+    }, import("toolcraft-schema").ObjectSchema<{
+        readonly path: import("toolcraft-schema").StringSchema;
+        readonly name: import("toolcraft-schema").OptionalSchema<import("toolcraft-schema").StringSchema>;
+    }>, undefined, InspectorResult[]> & {
+        readonly __agentKitCommandTypeInfo: import("toolcraft").CommandTypeInfo<"run", import("toolcraft-schema").ObjectSchema<{
+            readonly path: import("toolcraft-schema").StringSchema;
+            readonly name: import("toolcraft-schema").OptionalSchema<import("toolcraft-schema").StringSchema>;
+        }>, InspectorResult[], ("mcp" | "cli" | "sdk")[], undefined>;
+    }))[], ("mcp" | "cli" | "sdk")[], undefined>;
+};

package/packages/superintendent/dist/commands/inspector-group.js

@@ -0,0 +1,133 @@
+import { S, UserError, defineCommand, defineGroup } from "toolcraft";
+import { parseSuperintendentDoc } from "../document/parse.js";
+import { runAllInspectors, runInspector } from "../runtime/run-inspector.js";
+const inspectorListParams = S.Object({
+    path: S.String({ description: "Path to the superintendent markdown document" })
+});
+const inspectorRunParams = S.Object({
+    path: S.String({ description: "Path to the superintendent markdown document" }),
+    name: S.Optional(S.String({ description: "Name of the configured inspector to run" }))
+});
+export const inspectorListCommand = defineCommand({
+    name: "list",
+    description: "List configured inspectors from the document.",
+    positional: ["path"],
+    params: inspectorListParams,
+    scope: ["cli", "mcp", "sdk"],
+    handler: async ({ params, fs }) => {
+        const content = await readDocument(params.path, fs);
+        const document = parseSuperintendentDoc(params.path, content);
+        return Object.entries(document.frontmatter.inspectors ?? {}).map(([name, config]) => ({
+            name,
+            agent: config.agent,
+            mode: config.mode
+        }));
+    },
+    render: {
+        rich: (result, { logger, renderTable, getTheme }) => {
+            if (result.length === 0) {
+                logger.message("No inspectors configured.");
+                return;
+            }
+            logger.message(renderTable({
+                theme: getTheme(),
+                columns: [
+                    { name: "name", title: "Name", alignment: "left", maxLen: 32 },
+                    { name: "agent", title: "Agent", alignment: "left", maxLen: 24 },
+                    { name: "mode", title: "Mode", alignment: "left", maxLen: 12 }
+                ],
+                rows: result.map((inspector) => ({
+                    name: inspector.name,
+                    agent: inspector.agent,
+                    mode: inspector.mode ?? ""
+                }))
+            }));
+        },
+        markdown: (result) => renderInspectorListMarkdown(result),
+        json: (result) => result
+    }
+});
+export function createInspectorRunCommand(runners) {
+    const runInspectorImpl = runners?.runInspector ?? runInspector;
+    const runAllInspectorsImpl = runners?.runAllInspectors ?? runAllInspectors;
+    return defineCommand({
+        name: "run",
+        description: "Run one configured inspector, or all inspectors when no name is provided.",
+        positional: ["path", "name"],
+        params: inspectorRunParams,
+        scope: ["cli", "mcp", "sdk"],
+        handler: async ({ params, fs }) => {
+            const content = await readDocument(params.path, fs);
+            const document = parseSuperintendentDoc(params.path, content);
+            const defaultCwd = process.cwd();
+            if (params.name === undefined) {
+                return runAllInspectorsImpl(document, {}, { defaultCwd });
+            }
+            const config = document.frontmatter.inspectors?.[params.name];
+            if (config === undefined) {
+                throw new UserError(`Inspector not found: ${params.name}`);
+            }
+            return [await runInspectorImpl(params.name, config, document, {}, { defaultCwd })];
+        },
+        render: {
+            rich: (result, { logger }) => {
+                if (result.length === 0) {
+                    logger.message("No inspectors configured.");
+                    return;
+                }
+                logger.success(`Completed ${result.length} inspector run${result.length === 1 ? "" : "s"}.`);
+                for (const inspector of result) {
+                    logger.message(`${inspector.name}: ${inspector.summary || "(no output)"}`);
+                }
+            },
+            markdown: (result) => renderInspectorRunMarkdown(result),
+            json: (result) => result
+        }
+    });
+}
+export const inspectorRunCommand = createInspectorRunCommand();
+export function createInspectorGroup(runners) {
+    return defineGroup({
+        name: "inspector",
+        description: "Inspector commands.",
+        scope: ["cli", "mcp", "sdk"],
+        children: [inspectorListCommand, createInspectorRunCommand(runners)]
+    });
+}
+export const inspectorGroup = createInspectorGroup();
+async function readDocument(filePath, fs) {
+    try {
+        return await fs.readFile(filePath, "utf8");
+    }
+    catch (error) {
+        if (hasCode(error, "ENOENT")) {
+            throw new UserError(`Superintendent document not found: ${filePath}`);
+        }
+        throw error;
+    }
+}
+function renderInspectorListMarkdown(result) {
+    const lines = ["## Inspectors", ""];
+    if (result.length === 0) {
+        lines.push("No inspectors configured.");
+        return lines.join("\n");
+    }
+    for (const inspector of result) {
+        lines.push(`- ${inspector.name} (${inspector.agent}${inspector.mode ? `, ${inspector.mode}` : ""})`);
+    }
+    return lines.join("\n");
+}
+function renderInspectorRunMarkdown(result) {
+    const lines = ["## Inspector results", ""];
+    if (result.length === 0) {
+        lines.push("No inspectors configured.");
+        return lines.join("\n");
+    }
+    for (const inspector of result) {
+        lines.push(`### ${inspector.name}`, "", inspector.summary, "");
+    }
+    return lines.slice(0, -1).join("\n");
+}
+function hasCode(error, code) {
+    return typeof error === "object" && error !== null && "code" in error && error.code === code;
+}

package/packages/superintendent/dist/commands/install.d.ts

@@ -0,0 +1,31 @@
+import { type SkillScope } from "@poe-code/agent-skill-config";
+export type InstallResult = {
+    agent: string;
+    scope: SkillScope;
+    skillPath: string;
+    planDirectory: string;
+    planDirectoryCreated: boolean;
+};
+export declare const installCommand: import("toolcraft").Command<{
+    [x: string]: never;
+}, import("toolcraft-schema").ObjectSchema<{
+    readonly agent: import("toolcraft-schema").StringSchema;
+    readonly scope: import("toolcraft-schema").EnumSchema<readonly ["local", "global"]>;
+}>, undefined, {
+    agent: string;
+    scope: SkillScope;
+    skillPath: string;
+    planDirectory: string;
+    planDirectoryCreated: boolean;
+}> & {
+    readonly __agentKitCommandTypeInfo: import("toolcraft").CommandTypeInfo<"install", import("toolcraft-schema").ObjectSchema<{
+        readonly agent: import("toolcraft-schema").StringSchema;
+        readonly scope: import("toolcraft-schema").EnumSchema<readonly ["local", "global"]>;
+    }>, {
+        agent: string;
+        scope: SkillScope;
+        skillPath: string;
+        planDirectory: string;
+        planDirectoryCreated: boolean;
+    }, ("cli" | "sdk")[], undefined>;
+};