@kisev/agentomatic 11.0.0-dev.81.g683e7ae64567 → 11.0.2-dev.101.gae2702b7284e

package/dist/config-setup.js

@@ -1,19 +1,17 @@
-import { readFileSync } from "node:fs";
 import { randomUUID } from "node:crypto";
 import { lstat } from "node:fs/promises";
 import { homedir } from "node:os";
-import { dirname, join, resolve } from "node:path";
-import { fileURLToPath } from "node:url";
+import { join, resolve } from "node:path";
 import { archiveMutations } from "./installer.js";
 import { requirePackageVersion } from "./package-metadata.js";
 import { ensureDependency, planDependency } from "./self-install.js";
 import { applyTransaction, archiveRoot, deploymentRoot, LifecycleError, lifecycleRoot, inspectTransaction, readRegular, recoverTransaction, sha256, withLifecycleLock, } from "./lifecycle.js";
 import { applyJsoncEdits, parseJsonc } from "./jsonc.js";
+import { corePluginEdits, permissionEdits } from "./opencode-config.js";
 const PACKAGE_NAME = "@kisev/agentomatic";
-const LEGACY_PACKAGE_NAME = "@kisev/skills-opencode";
-const packageRoot = resolve(dirname(fileURLToPath(import.meta.url)), "..");
 const XDG_STATE_GLOB = "~/.local/state/agent-skills/**";
 const OPENCODE_SKILLS_GLOB = "~/.config/opencode/skills/**";
+const AGENTS_SKILLS_GLOB = "~/.agents/skills/**";
 const SECRET_PATHS = [
     "**/.env",
     "**/.env.*",
@@ -48,16 +46,10 @@ export const CONFIG_FRAGMENTS = [
     },
     {
         name: "skills-state-permissions",
-        description: "Allow the standard skills XDG state paths without per-run prompts",
+        description: "Allow the canonical ~/.agents/skills tree and legacy skills state paths without per-run prompts",
         targets: ["opencode", "kilo", "mimo"],
         file: "main",
     },
-    {
-        name: "lsp-preset",
-        description: "Add LSP servers from the shared catalog (OpenCode only)",
-        targets: ["opencode"],
-        file: "main",
-    },
     {
         name: "secrets-guard",
         description: "Deny reads and edits of common secret files",
@@ -72,7 +64,7 @@ export const CONFIG_FRAGMENTS = [
     },
     {
         name: "tui-schema",
-        description: "Unify each agent TUI file: schema, theme, stacked diffs, and leader keybinds",
+        description: "Configure terminal settings: OpenCode V2 cli.json or Kilo/MiMo TUI files",
         targets: ["opencode", "kilo", "mimo"],
         file: "tui",
     },
@@ -137,23 +129,26 @@ const UNIFIED_TUI_KEYBINDS = {
     messages_toggle_conceal: "<leader>h,<leader>р",
     tips_toggle: "<leader>h,<leader>р",
 };
-const LSP_SERVER_COMMANDS = {
-    python: ["basedpyright-langserver", "--stdio"],
-    typescript: ["typescript-language-server", "--stdio"],
-    yaml: ["yaml-language-server", "--stdio"],
-    shell: ["bash-language-server", "start"],
+const OPENCODE_KEYBINDS = {
+    "command.palette.show": "alt+p",
+    "app.exit": "ctrl+d,<leader>q,<leader>й",
+    "session.first": "ctrl+g",
+    "session.last": "ctrl+alt+g",
+    "prompt.editor": "<leader>e,<leader>у",
+    "theme.switch": "<leader>t,<leader>е",
+    "session.sidebar.toggle": "<leader>b,<leader>и",
+    "opencode.status": "<leader>s,<leader>ы",
+    "session.export": "<leader>x,<leader>ч",
+    "session.new": "<leader>n,<leader>т",
+    "session.list": "<leader>l,<leader>д",
+    "session.timeline": "<leader>g,<leader>п",
+    "session.compact": "<leader>c,<leader>с",
+    "model.list": "<leader>m,<leader>ь",
+    "agent.list": "<leader>a,<leader>ф",
+    "messages.copy": "<leader>y,<leader>н",
+    "session.undo": "<leader>u,<leader>г",
+    "session.redo": "<leader>r,<leader>к",
 };
-function lspCatalog() {
-    const raw = readFileSync(resolve(packageRoot, "dist", "assets", "lsp-catalog.json"), "utf8");
-    const catalog = JSON.parse(raw);
-    if (!Array.isArray(catalog.servers))
-        throw new ConfigSetupError("invalid_package", "LSP catalog is unavailable");
-    return catalog.servers
-        .filter((server) => typeof server.name === "string" &&
-        Array.isArray(server.extensions) &&
-        server.extensions.every((extension) => typeof extension === "string"))
-        .filter((server) => LSP_SERVER_COMMANDS[server.name]);
-}
 function mapAllowsAll(value) {
     return Boolean(value &&
         typeof value === "object" &&
@@ -171,21 +166,28 @@ function fragmentEdits(fragment, target, current) {
         ? value.permission
         : {};
     if (fragment === "core-plugin") {
-        const key = "plugins" in value ? "plugins" : "plugin";
-        return [
-            { kind: "set-if-absent", path: ["$schema"], value: "https://opencode.ai/config.json" },
-            { kind: "set-if-absent", path: [key], value: [] },
-            {
-                kind: "replace-array-value",
-                path: [key],
-                from: LEGACY_PACKAGE_NAME,
-                to: PACKAGE_NAME,
-            },
-            { kind: "append-unique", path: [key], value: PACKAGE_NAME },
-        ];
+        return corePluginEdits(value);
     }
     if (fragment === "skills-state-permissions") {
-        const statePaths = target === "opencode" ? [XDG_STATE_GLOB, OPENCODE_SKILLS_GLOB] : [XDG_STATE_GLOB];
+        const statePaths = target === "opencode"
+            ? [XDG_STATE_GLOB, OPENCODE_SKILLS_GLOB, AGENTS_SKILLS_GLOB]
+            : [XDG_STATE_GLOB];
+        if (target === "opencode")
+            return permissionEdits(value, [
+                ...statePaths.flatMap((resource) => [
+                    { action: "read", resource, effect: "allow" },
+                    { action: "external_directory", resource, effect: "allow" },
+                ]),
+                { action: "edit", resource: XDG_STATE_GLOB, effect: "allow" },
+                // Directory enumeration (glob/list) targets the roots themselves, which
+                // the tree globs above do not match; allow those exact directories.
+                ...statePaths.map((resource) => ({
+                    action: "external_directory",
+                    resource: resource.replace(/\/\*\*$/, ""),
+                    effect: "allow",
+                })),
+                { action: "external_directory", resource: "~/.agents", effect: "allow" },
+            ]);
         const edits = [];
         if (!mapAllowsAll(permission.read))
             edits.push(...permissionMapEdits(["permission", "read"], Object.fromEntries(statePaths.map((glob) => [glob, "allow"]))));
@@ -195,14 +197,15 @@ function fragmentEdits(fragment, target, current) {
             edits.push(...permissionMapEdits(["permission", "external_directory"], Object.fromEntries(statePaths.map((glob) => [glob, "allow"]))));
         return edits;
     }
-    if (fragment === "lsp-preset") {
-        return lspCatalog().map((server) => ({
-            kind: "set-if-absent",
-            path: ["lsp", server.name],
-            value: { command: LSP_SERVER_COMMANDS[server.name], extensions: server.extensions },
-        }));
-    }
     if (fragment === "secrets-guard") {
+        if (target === "opencode")
+            return permissionEdits(value, [
+                ...SECRET_PATHS.flatMap((glob) => [
+                    { action: "read", resource: glob.replace(/^\*\*\//, "*"), effect: "deny" },
+                    { action: "edit", resource: glob.replace(/^\*\*\//, "*"), effect: "deny" },
+                ]),
+                { action: "read", resource: "*.env.example", effect: "allow" },
+            ]);
         const deny = Object.fromEntries(SECRET_PATHS.map((glob) => [glob, "deny"]));
         return [
             ...permissionMapEdits(["permission", "read"], {
@@ -220,8 +223,18 @@ function fragmentEdits(fragment, target, current) {
             { kind: "set-if-absent", path: ["mcp_tool_display"], value: "expanded" },
         ];
     }
+    if (target === "opencode")
+        return [
+            { kind: "set-if-absent", path: ["$schema"], value: "https://opencode.ai/v2/cli.json" },
+            { kind: "set-if-absent", path: ["theme", "name"], value: "ayu" },
+            ...Object.entries(OPENCODE_KEYBINDS).map(([key, value]) => ({
+                kind: "set-if-absent",
+                path: ["keybinds", key],
+                value,
+            })),
+        ];
     const tuiSchemas = {
-        opencode: "https://opencode.ai/tui.json",
+        opencode: undefined,
         kilo: undefined,
         mimo: "https://mimo.xiaomi.com/mimocode/tui.json",
     };
@@ -309,9 +322,9 @@ async function resolveTargetFile(target, scope, cwd, home, kind = "main") {
         return {
             target,
             root: globalRoot,
-            path: "tui.json",
-            absolute: join(globalRoot, "tui.json"),
-            exists: await existing(globalRoot, "tui.json"),
+            path: "cli.json",
+            absolute: join(globalRoot, "cli.json"),
+            exists: await existing(globalRoot, "cli.json"),
         };
     }
     if (target === "opencode") {
@@ -405,6 +418,20 @@ async function build(selection, scope, cwd = process.cwd(), home = homedir()) {
             for (const fragment of selection.fragments) {
                 if (!applicable(fragment, target) || fragmentFileKind(fragment) !== kind)
                     continue;
+                if (target === "opencode" &&
+                    kind === "tui" &&
+                    !file.exists &&
+                    ((await readRegular(join(file.root, "tui.json"))) ||
+                        (await readRegular(join(file.root, "tui.jsonc"))))) {
+                    operations.push({
+                        target,
+                        path: file.absolute,
+                        fragment,
+                        operation: "conflict",
+                        reason: "Start OpenCode V2 once to migrate existing TUI preferences into cli.json before applying terminal presets",
+                    });
+                    continue;
+                }
                 let parsed = undefined;
                 try {
                     parsed = parseJsonc(text);
@@ -575,6 +602,8 @@ export async function applyConfigSetup(selection, scope, cwd = process.cwd(), ho
                     await provision();
                     return built.plan;
                 }
+                if (!built.plan.operations.some((operation) => operation.operation === "conflict"))
+                    return built.plan;
                 throw new ConfigSetupError("invalid_state", "Config setup plan has no applicable changes");
             }
             const backups = [];

package/dist/contracts.js

@@ -9,6 +9,32 @@ function strings(value) {
 export function validateAgentReport(agent, report, card) {
     if (!object(report))
         throw new Error("agent report must be an object");
+    if ((agent === "review" || agent === "critic") &&
+        !card &&
+        report.schema === "portable-gitlab/critic-receipt/v2") {
+        const required = [
+            "schema",
+            "evidence_digest",
+            "run_id",
+            "session_id",
+            "findings",
+            "external_mutations",
+        ];
+        const allowed = [...required, "scope_digest", "target_finding_ids"];
+        if (!required.every((key) => key in report) ||
+            Object.keys(report).some((key) => !allowed.includes(key)) ||
+            !/^[0-9a-f]{64}$/.test(String(report.evidence_digest)) ||
+            typeof report.run_id !== "string" ||
+            !report.run_id ||
+            typeof report.session_id !== "string" ||
+            !report.session_id ||
+            !Array.isArray(report.findings) ||
+            report.external_mutations !== false ||
+            ("scope_digest" in report && !/^[0-9a-f]{64}$/.test(String(report.scope_digest))) ||
+            ("target_finding_ids" in report && !strings(report.target_finding_ids)))
+            throw new Error("code-review critic receipt has an invalid transport envelope");
+        return;
+    }
     if (agent === "critic" && !card && "review_report" in report) {
         validateAgentReport("review", report);
         return;

package/dist/doctor.d.ts

@@ -9,7 +9,6 @@ export type DoctorCheck = {
 };
 export type DoctorHost = {
     config?: () => Promise<unknown>;
-    lsp?: () => Promise<unknown>;
 };
 export type DoctorReport = {
     schema_version: 1;

package/dist/doctor.js

@@ -12,6 +12,7 @@ import { archiveRoot, assertSafePath, deploymentRoot, lifecycleRoot, } from "./l
 import { inspectReconcile } from "./reconcile.js";
 import { readPackageVersion } from "./package-metadata.js";
 import { planDependency } from "./self-install.js";
+import { parseJsonc } from "./jsonc.js";
 import { readRtkStats, rtkCharsSaved, rtkStatsPath, rtkTokensSavedEstimate, } from "./plugins/rtk.js";
 import { stateRoot } from "./runtime/state.js";
 const run = promisify(execFile);
@@ -114,20 +115,19 @@ function agentManifestValid(raw) {
 }
 function redactedConfig(value) {
     const object = value && typeof value === "object" && !Array.isArray(value) ? value : {};
-    const configuredPlugins = object.plugins ?? object.plugin;
+    const configuredPlugins = object.plugins;
     const rawPlugins = Array.isArray(configuredPlugins)
         ? configuredPlugins.flatMap((item) => {
             if (typeof item === "string")
                 return [item];
-            if (Array.isArray(item) && typeof item[0] === "string")
-                return [item[0]];
             if (item && typeof item === "object" && typeof item.package === "string")
                 return [item.package];
             return [];
         })
         : [];
     const knownPlugins = new Set([packageName, ...CATALOG.plugins]);
-    const plugins = rawPlugins.filter((plugin) => knownPlugins.has(plugin));
+    const normalizePlugin = (plugin) => plugin === packageName || plugin.startsWith(`${packageName}@`) ? packageName : plugin;
+    const plugins = rawPlugins.map(normalizePlugin).filter((plugin) => knownPlugins.has(plugin));
     const enabled = plugins.filter((plugin) => plugin === packageName ||
         CATALOG.plugins.includes(plugin));
     return {
@@ -138,18 +138,14 @@ function redactedConfig(value) {
         keys: Object.keys(object)
             .filter((key) => [
             "$schema",
-            "theme",
-            "keybinds",
-            "logLevel",
-            "command",
+            "commands",
             "watcher",
-            "plugin",
             "plugins",
             "lsp",
             "formatter",
-            "provider",
-            "agent",
-            "permission",
+            "providers",
+            "agents",
+            "permissions",
             "compaction",
             "model",
         ].includes(key))
@@ -159,12 +155,26 @@ function redactedConfig(value) {
 }
 async function localConfig(scope, cwd, home) {
     const paths = scope === "project"
-        ? [join(cwd, "opencode.json"), join(cwd, ".opencode", "opencode.json")]
-        : [join(home, ".config", "opencode", "opencode.json")];
+        ? [
+            join(cwd, "opencode.json"),
+            join(cwd, "opencode.jsonc"),
+            join(cwd, ".opencode", "opencode.json"),
+            join(cwd, ".opencode", "opencode.jsonc"),
+        ]
+        : [
+            join(home, ".config", "opencode", "opencode.json"),
+            join(home, ".config", "opencode", "opencode.jsonc"),
+        ];
     for (const path of paths) {
         const value = await regular(path);
         if (value.status === "present") {
-            const parsed = json(value.raw);
+            let parsed;
+            try {
+                parsed = parseJsonc(value.raw.toString("utf8"));
+            }
+            catch {
+                parsed = undefined;
+            }
             return parsed
                 ? { projection: redactedConfig(parsed), source: path }
                 : { incomplete: true, source: path };
@@ -254,7 +264,7 @@ async function executableAvailable(name) {
     }
     return false;
 }
-async function lspFacts(project, host, partial) {
+async function lspFacts(project, partial) {
     const suffixes = new Set();
     let scanIncomplete = false;
     const visit = async (root) => {
@@ -281,7 +291,6 @@ async function lspFacts(project, host, partial) {
     await visit(project);
     if (scanIncomplete)
         partial.push("lsp.project-files");
-    const disabled = process.env.OPENCODE_DISABLE_LSP_DOWNLOAD === "true";
     const servers = await Promise.all(lspCatalog.servers.map(async (server) => {
         let available = false;
         available = await executableAvailable(server.executable);
@@ -289,48 +298,20 @@ async function lspFacts(project, host, partial) {
         return {
             name: server.name,
             applicable,
-            configured: applicable,
+            configured: false,
             binary_available: available,
-            active: applicable && available && !disabled,
-            runtime_status: "unavailable",
+            active: false,
+            runtime_status: "unsupported",
             requirement_class: server.requirement_class,
-            reason: !applicable
-                ? "not-selected"
-                : disabled
-                    ? "download-disabled"
-                    : !available
-                        ? "missing-dependency"
-                        : "available",
+            reason: "unsupported-in-opencode-v2",
             missing: available ? [] : [server.executable],
             install: `Install ${server.executable} with your project toolchain.`,
         };
     }));
-    let runtimeStatus = "unavailable";
-    if (host?.lsp) {
-        try {
-            const value = await host.lsp();
-            runtimeStatus = Array.isArray(value)
-                ? value.map((item) => {
-                    const entry = item && typeof item === "object" ? item : {};
-                    return {
-                        id: typeof entry.id === "string" ? entry.id : "unknown",
-                        name: typeof entry.name === "string" ? entry.name : "unknown",
-                        status: entry.status === "connected" || entry.status === "error" ? entry.status : "unknown",
-                    };
-                })
-                : { status: "unavailable" };
-        }
-        catch {
-            partial.push("lsp.runtime-status");
-        }
-    }
-    else
-        partial.push("lsp.runtime-status");
     return {
         schema_version: 1,
         catalog_version: lspCatalog.catalog_version,
-        download_disabled: disabled,
-        runtime_status: runtimeStatus,
+        runtime_status: "unsupported",
         servers,
     };
 }
@@ -495,7 +476,7 @@ export async function collectDoctorFacts(scope, cwd = process.cwd(), home = home
         source: config.source ?? "host-or-file-unavailable",
     }, [
         "Inspect OpenCode configuration without exposing secrets.",
-        "Local plugin wrappers in the deployment plugins directory load automatically without a plugin array entry.",
+        "Local plugin wrappers in the deployment plugins directory load automatically without a plugins array entry.",
     ]));
     const wired = (config.projection?.enabled_plugins ?? []).includes(packageName) ||
         (hostConfig?.enabled_plugins ?? []).includes(packageName);
@@ -627,7 +608,7 @@ export async function collectDoctorFacts(scope, cwd = process.cwd(), home = home
     }, lifecycleFiles.incomplete
         ? ["Resolve inaccessible lifecycle state before applying a mutation."]
         : undefined));
-    const tools = await Promise.all(["opencode", ...lspCatalog.servers.map((server) => server.executable)].map(async (name) => {
+    const tools = await Promise.all(["opencode"].map(async (name) => {
         try {
             const result = await run(name, ["--version"], { timeout: 1000 });
             return {
@@ -644,7 +625,7 @@ export async function collectDoctorFacts(scope, cwd = process.cwd(), home = home
         }
     }));
     checks.push(check("host.tools", tools.some((item) => item.name === "opencode" && item.available) ? "pass" : "incomplete", "External tool availability is reported", { tools: tools.map((item) => `${item.name}:${item.available ? "available" : "missing"}`) }, ["Install OpenCode or missing external tools when needed."]));
-    const lsp = await lspFacts(project, host, partial);
+    const lsp = await lspFacts(project, partial);
     const counts = { pass: 0, warn: 0, fail: 0, incomplete: 0 };
     for (const item of checks)
         counts[item.status] += 1;

package/dist/index.d.ts

@@ -1,6 +1,4 @@
-import type { Plugin as V2Plugin } from "@opencode/plugin";
-import { z } from "zod";
-import { type Category, type RoutingInput } from "./routing.js";
+import type { Plugin } from "@opencode/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";
@@ -10,132 +8,8 @@ export type OpenCodeOptions = {
     rtk?: RtkOptions;
     zedBell?: ZedBellOptions;
 };
-type RuntimeInput = {
-    directory: string;
-    client?: {
-        app?: {
-            agents?: (input: {
-                query: {
-                    directory: string;
-                };
-            }) => Promise<{
-                data?: unknown;
-            }>;
-        };
-    };
-};
-export declare const server: (input: RuntimeInput) => Promise<{
-    tool: {
-        route: {
-            description: string;
-            args: {
-                action: z.ZodEnum<{
-                    dispatch: "dispatch";
-                    preview: "preview";
-                }>;
-                category: z.ZodEnum<{
-                    architecture: "architecture";
-                    exploration: "exploration";
-                    implementation: "implementation";
-                    review: "review";
-                }>;
-                task: z.ZodString;
-                requirements: z.ZodDefault<z.ZodArray<z.ZodString>>;
-                execution_card: z.ZodOptional<z.ZodAny>;
-                override: z.ZodOptional<z.ZodString>;
-                trusted_override: z.ZodOptional<z.ZodBoolean>;
-                budget: z.ZodOptional<z.ZodObject<{
-                    cost_class: z.ZodOptional<z.ZodString>;
-                    latency_class: z.ZodOptional<z.ZodString>;
-                }, z.core.$strip>>;
-                decision: z.ZodOptional<z.ZodAny>;
-            };
-            execute(args: {
-                action: "preview" | "dispatch";
-                category: Category;
-                task: string;
-                requirements: string[];
-                execution_card?: unknown;
-                override?: string;
-                trusted_override?: boolean;
-                budget?: RoutingInput["budget"];
-                decision?: unknown;
-            }, context: {
-                sessionID: string;
-            }): Promise<string>;
-        };
-    };
-    "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>;
-}>;
 declare const _default: {
     id: string;
-    server: (input: RuntimeInput) => Promise<{
-        tool: {
-            route: {
-                description: string;
-                args: {
-                    action: z.ZodEnum<{
-                        dispatch: "dispatch";
-                        preview: "preview";
-                    }>;
-                    category: z.ZodEnum<{
-                        architecture: "architecture";
-                        exploration: "exploration";
-                        implementation: "implementation";
-                        review: "review";
-                    }>;
-                    task: z.ZodString;
-                    requirements: z.ZodDefault<z.ZodArray<z.ZodString>>;
-                    execution_card: z.ZodOptional<z.ZodAny>;
-                    override: z.ZodOptional<z.ZodString>;
-                    trusted_override: z.ZodOptional<z.ZodBoolean>;
-                    budget: z.ZodOptional<z.ZodObject<{
-                        cost_class: z.ZodOptional<z.ZodString>;
-                        latency_class: z.ZodOptional<z.ZodString>;
-                    }, z.core.$strip>>;
-                    decision: z.ZodOptional<z.ZodAny>;
-                };
-                execute(args: {
-                    action: "preview" | "dispatch";
-                    category: Category;
-                    task: string;
-                    requirements: string[];
-                    execution_card?: unknown;
-                    override?: string;
-                    trusted_override?: boolean;
-                    budget?: RoutingInput["budget"];
-                    decision?: unknown;
-                }, context: {
-                    sessionID: string;
-                }): Promise<string>;
-            };
-        };
-        "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>;
-    }>;
-    setup(ctx: V2Plugin.Context): Promise<(() => Promise<void>) | undefined>;
+    setup(ctx: Plugin.Context): Promise<void>;
 };
 export default _default;