@kisev/agentomatic 11.0.0-dev.46.gfbe1e4c6992e

package/dist/generate-assets.js

@@ -0,0 +1,54 @@
+import { copyFile, cp, mkdir, readFile, readdir, unlink, writeFile } from "node:fs/promises";
+import { dirname, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { COMMAND_REGISTRY, renderCommand } from "./registry.js";
+const packageRoot = resolve(dirname(fileURLToPath(import.meta.url)), "..");
+const arguments_ = process.argv.slice(2);
+const rootIndex = arguments_.indexOf("--root");
+if (rootIndex !== -1 && !arguments_[rootIndex + 1])
+    throw new Error("--root requires a path");
+const commandsRoot = rootIndex === -1
+    ? resolve(packageRoot, "dist", "assets", "commands")
+    : resolve(arguments_[rootIndex + 1] ?? "");
+const check = arguments_.includes("--check");
+const expectedNames = new Set(COMMAND_REGISTRY.map((command) => `${command.name}.md`));
+if (!check)
+    await mkdir(commandsRoot, { recursive: true });
+const entries = await readdir(commandsRoot, { withFileTypes: true }).catch(() => []);
+for (const entry of entries) {
+    if (entry.isFile() && !expectedNames.has(entry.name)) {
+        if (check)
+            throw new Error(`unexpected generated asset: ${entry.name}`);
+        await unlink(resolve(commandsRoot, entry.name));
+    }
+    else if (!entry.isFile()) {
+        throw new Error(`unexpected entry in generated assets: ${entry.name}`);
+    }
+}
+for (const command of COMMAND_REGISTRY) {
+    const destination = resolve(commandsRoot, `${command.name}.md`);
+    const expected = renderCommand(command);
+    if (check) {
+        const actual = await readFile(destination, "utf8").catch(() => "");
+        if (actual !== expected)
+            throw new Error(`generated asset drift: ${command.name}.md`);
+    }
+    else {
+        await writeFile(destination, expected, "utf8");
+    }
+}
+if (rootIndex === -1) {
+    const catalog = resolve(packageRoot, "..", "..", "shared", "references", "lsp-catalog.json");
+    const destination = resolve(packageRoot, "dist", "assets", "lsp-catalog.json");
+    if (check) {
+        if ((await readFile(destination).catch(() => Buffer.alloc(0))).compare(await readFile(catalog)) !== 0)
+            throw new Error("generated asset drift: lsp-catalog.json");
+    }
+    else {
+        await mkdir(dirname(destination), { recursive: true });
+        await copyFile(catalog, destination);
+        await cp(resolve(packageRoot, "assets", "agents"), resolve(packageRoot, "dist", "assets", "agents"), { recursive: true });
+        await cp(resolve(packageRoot, "assets", "plugins"), resolve(packageRoot, "dist", "assets", "plugins"), { recursive: true });
+        await copyFile(resolve(packageRoot, "assets", "migration-inventory.json"), resolve(packageRoot, "dist", "assets", "migration-inventory.json"));
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,125 @@
+import { type PluginInput } from "@opencode-ai/plugin";
+import rulesInjector, { type RulesInjectorOptions } from "./plugins/rules-injector.js";
+import rtk, { type RtkOptions } from "./plugins/rtk.js";
+import zedBell, { type ZedBellOptions } from "./plugins/zed-bell.js";
+import memomatic, { type MemomaticOptions } from "./plugins/memomatic.js";
+export { rulesInjector, rtk, zedBell, memomatic };
+export type OpenCodeOptions = {
+    rulesInjector?: RulesInjectorOptions;
+    rtk?: RtkOptions;
+    zedBell?: ZedBellOptions;
+    memomatic?: MemomaticOptions;
+};
+declare const plugin: (input: PluginInput) => Promise<{
+    tool: {
+        route: {
+            description: string;
+            args: {
+                action: import("zod").ZodEnum<{
+                    dispatch: "dispatch";
+                    preview: "preview";
+                }>;
+                category: import("zod").ZodEnum<{
+                    architecture: "architecture";
+                    exploration: "exploration";
+                    implementation: "implementation";
+                    review: "review";
+                }>;
+                task: import("zod").ZodString;
+                requirements: import("zod").ZodDefault<import("zod").ZodArray<import("zod").ZodString>>;
+                execution_card: import("zod").ZodOptional<import("zod").ZodAny>;
+                override: import("zod").ZodOptional<import("zod").ZodString>;
+                trusted_override: import("zod").ZodOptional<import("zod").ZodBoolean>;
+                budget: import("zod").ZodOptional<import("zod").ZodObject<{
+                    cost_class: import("zod").ZodOptional<import("zod").ZodString>;
+                    latency_class: import("zod").ZodOptional<import("zod").ZodString>;
+                }, import("zod/v4/core").$strip>>;
+                decision: import("zod").ZodOptional<import("zod").ZodAny>;
+            };
+            execute(args: {
+                action: "dispatch" | "preview";
+                category: "architecture" | "exploration" | "implementation" | "review";
+                task: string;
+                requirements: string[];
+                execution_card?: any;
+                override?: string | undefined;
+                trusted_override?: boolean | undefined;
+                budget?: {
+                    cost_class?: string | undefined;
+                    latency_class?: string | undefined;
+                } | undefined;
+                decision?: any;
+            }, context: import("@opencode-ai/plugin").ToolContext): Promise<import("@opencode-ai/plugin").ToolResult>;
+        };
+    };
+    "tool.execute.before": (input: {
+        tool: string;
+        sessionID: string;
+    }, output: {
+        args: unknown;
+    }) => Promise<void>;
+    "tool.execute.after": (input: {
+        tool: string;
+        sessionID: string;
+        args: unknown;
+    }, output: {
+        output: string;
+    }) => Promise<void>;
+}>;
+export declare const server: (input: PluginInput) => Promise<{
+    tool: {
+        route: {
+            description: string;
+            args: {
+                action: import("zod").ZodEnum<{
+                    dispatch: "dispatch";
+                    preview: "preview";
+                }>;
+                category: import("zod").ZodEnum<{
+                    architecture: "architecture";
+                    exploration: "exploration";
+                    implementation: "implementation";
+                    review: "review";
+                }>;
+                task: import("zod").ZodString;
+                requirements: import("zod").ZodDefault<import("zod").ZodArray<import("zod").ZodString>>;
+                execution_card: import("zod").ZodOptional<import("zod").ZodAny>;
+                override: import("zod").ZodOptional<import("zod").ZodString>;
+                trusted_override: import("zod").ZodOptional<import("zod").ZodBoolean>;
+                budget: import("zod").ZodOptional<import("zod").ZodObject<{
+                    cost_class: import("zod").ZodOptional<import("zod").ZodString>;
+                    latency_class: import("zod").ZodOptional<import("zod").ZodString>;
+                }, import("zod/v4/core").$strip>>;
+                decision: import("zod").ZodOptional<import("zod").ZodAny>;
+            };
+            execute(args: {
+                action: "dispatch" | "preview";
+                category: "architecture" | "exploration" | "implementation" | "review";
+                task: string;
+                requirements: string[];
+                execution_card?: any;
+                override?: string | undefined;
+                trusted_override?: boolean | undefined;
+                budget?: {
+                    cost_class?: string | undefined;
+                    latency_class?: string | undefined;
+                } | undefined;
+                decision?: any;
+            }, context: import("@opencode-ai/plugin").ToolContext): Promise<import("@opencode-ai/plugin").ToolResult>;
+        };
+    };
+    "tool.execute.before": (input: {
+        tool: string;
+        sessionID: string;
+    }, output: {
+        args: unknown;
+    }) => Promise<void>;
+    "tool.execute.after": (input: {
+        tool: string;
+        sessionID: string;
+        args: unknown;
+    }, output: {
+        output: string;
+    }) => Promise<void>;
+}>;
+export default plugin;

package/dist/index.js

@@ -0,0 +1,141 @@
+import { tool } from "@opencode-ai/plugin";
+import { CATEGORIES, RoutingGate, } from "./routing.js";
+import rulesInjector from "./plugins/rules-injector.js";
+import rtk from "./plugins/rtk.js";
+import zedBell from "./plugins/zed-bell.js";
+import memomatic from "./plugins/memomatic.js";
+import { digest } from "./lifecycle.js";
+export { rulesInjector, rtk, zedBell, memomatic };
+const plugin = (async (input) => {
+    const gate = new RoutingGate();
+    const hostInventory = async () => {
+        if (!input.client?.app?.agents)
+            throw new Error("Resolved OpenCode agent inventory is unavailable");
+        const response = await input.client.app.agents({ query: { directory: input.directory } });
+        const raw = response.data;
+        if (!Array.isArray(raw))
+            throw new Error("Resolved OpenCode agent inventory is malformed");
+        const capabilities = {
+            mapper: ["read", "search"],
+            architect: ["read", "architecture"],
+            worker: ["read", "write", "verify"],
+            review: ["read", "review"],
+            critic: ["read", "review"],
+        };
+        const agents = raw.map((value) => {
+            const agent = value;
+            if (typeof agent.name !== "string" || !agent.name)
+                throw new Error("Resolved OpenCode agent has no name");
+            return {
+                agent: agent.name,
+                available: true,
+                capabilities: capabilities[agent.name] ??
+                    (/^critic-[a-z0-9]+(?:-[a-z0-9]+)*$/.test(agent.name) ? ["read", "review"] : ["read"]),
+                tools: [
+                    "read",
+                    ...(agent.permission?.edit !== "deny" ? ["edit"] : []),
+                    ...Object.entries(agent.tools ?? {})
+                        .filter(([, enabled]) => enabled)
+                        .map(([name]) => name),
+                    ...Object.entries(agent.permission?.bash ?? {})
+                        .filter(([, mode]) => mode !== "deny")
+                        .map(() => "bash"),
+                ].filter((name, index, list) => list.indexOf(name) === index),
+            };
+        });
+        return { agents, revision: digest(raw) };
+    };
+    const route = tool({
+        description: "Resolve a capability category and dispatch one eligible agent through a one-use Task receipt gate.",
+        args: {
+            action: tool.schema.enum(["preview", "dispatch"]),
+            category: tool.schema.enum(CATEGORIES),
+            task: tool.schema.string(),
+            requirements: tool.schema.array(tool.schema.string()).default([]),
+            execution_card: tool.schema.any().optional(),
+            override: tool.schema.string().optional(),
+            trusted_override: tool.schema.boolean().optional(),
+            budget: tool.schema
+                .object({
+                cost_class: tool.schema.string().optional(),
+                latency_class: tool.schema.string().optional(),
+            })
+                .optional(),
+            decision: tool.schema.any().optional(),
+        },
+        async execute(args, context) {
+            const inventory = await hostInventory();
+            const input = {
+                category: args.category,
+                task: args.task,
+                requirements: args.requirements,
+                agents: inventory.agents,
+                inventory_revision: inventory.revision,
+                execution_card: args.execution_card,
+                override: args.override,
+                trusted_override: args.trusted_override,
+                budget: args.budget,
+            };
+            if (args.action === "preview")
+                return JSON.stringify(gate.preview(input));
+            const decision = gate.dispatch(input, args.decision);
+            if (decision.agent === "worker" && args.execution_card === undefined)
+                throw new Error("implementation dispatch requires a confirmed execution card");
+            const receipt = gate.grant(context.sessionID, decision, {
+                task: args.task,
+                requirements: args.requirements,
+                card: args.execution_card,
+            });
+            return JSON.stringify({ decision, receipt, status: "routed" });
+        },
+    });
+    return {
+        tool: { route },
+        "tool.execute.before": async (input, output) => {
+            if (input.tool !== "task")
+                return;
+            const args = output.args && typeof output.args === "object"
+                ? output.args
+                : {};
+            const agent = typeof args.agent === "string"
+                ? args.agent
+                : typeof args.subagent_type === "string"
+                    ? args.subagent_type
+                    : undefined;
+            if (!agent)
+                throw new Error("Native Task requires an explicit agent and an active routing receipt");
+            const hasBinding = "task" in args || "requirements" in args || "execution_card" in args;
+            if (!hasBinding)
+                gate.consume(input.sessionID, agent);
+            else {
+                const task = typeof args.task === "string" ? args.task : "";
+                const requirements = Array.isArray(args.requirements)
+                    ? args.requirements
+                    : [];
+                gate.consume(input.sessionID, agent, { task, requirements, card: args.execution_card });
+            }
+        },
+        "tool.execute.after": async (input, output) => {
+            if (input.tool !== "task")
+                return;
+            const args = input.args && typeof input.args === "object" ? input.args : {};
+            const agent = typeof args.agent === "string"
+                ? args.agent
+                : typeof args.subagent_type === "string"
+                    ? args.subagent_type
+                    : undefined;
+            if (!agent)
+                throw new Error("Task result requires an explicit agent");
+            let result;
+            try {
+                result = JSON.parse(output.output);
+            }
+            catch {
+                throw new Error("Task result must be JSON structured report");
+            }
+            gate.complete(input.sessionID, agent, result);
+        },
+    };
+});
+export const server = plugin;
+export default plugin;

package/dist/installer.d.ts

@@ -0,0 +1,56 @@
+import { LifecycleError, type FileMutation, type Scope, type SupersededPlan, type TransactionOptions } from "./lifecycle.js";
+import { CATALOG } from "./catalog.js";
+import { type FixedAgentRole } from "./agent-profiles.js";
+export type { Scope } from "./lifecycle.js";
+export type Action = "install" | "uninstall";
+export type Operation = "create" | "update" | "remove" | "unchanged" | "missing" | "conflict" | "archive-pending";
+export type PlanItem = {
+    path: string;
+    operation: Operation;
+    reason?: string;
+    sha256?: string;
+};
+export type SelectablePlugin = (typeof CATALOG.plugins)[number];
+export type InstallerSelection = {
+    commands: string[];
+    agents: FixedAgentRole[];
+    plugins: SelectablePlugin[];
+    core_activation: boolean;
+};
+export type Plan = {
+    schema_version: 2;
+    action: Action;
+    scope: Scope;
+    root: string;
+    package_version: string;
+    selection: InstallerSelection;
+    operations: PlanItem[];
+    plan_digest: string;
+    confirmation_digest?: string;
+    superseded_plan?: SupersededPlan;
+    digest: string;
+    receipt_expires_at?: string;
+    requires_restart: boolean;
+};
+type ManifestFile = {
+    sha256: string;
+    mode: number;
+    kind: "command" | "agent" | "plugin" | "state";
+};
+export type ArchiveCandidate = {
+    path: string;
+    record: ManifestFile;
+    content: Buffer;
+    reason: string;
+    kind: "command" | "agent" | "plugin" | "state";
+};
+export declare const SELECTABLE_PLUGINS: SelectablePlugin[];
+export declare const SKILL_COMMANDS: string[];
+export declare function defaultSelection(): InstallerSelection;
+export declare function normalizeSelection(value?: Partial<InstallerSelection>): InstallerSelection;
+export declare class InstallerError extends LifecycleError {
+}
+export declare function archiveMutations(candidates: readonly ArchiveCandidate[], scope: Scope, cwd: string, home: string, sourceVersion: string): Promise<FileMutation[]>;
+export declare function preview(action: Action, scope: Scope, cwd?: string, home?: string, selection?: Partial<InstallerSelection>): Promise<Plan>;
+export declare function apply(action: Action, scope: Scope, confirmationDigest: string, cwd?: string, home?: string, options?: TransactionOptions, selection?: Partial<InstallerSelection>): Promise<Plan>;
+export declare function result(plan: Plan, applied: boolean): string;