@kisev/agentomatic 11.0.2-dev.92.gc67bdc97fcd1 → 11.0.2

package/dist/config-setup.js

@@ -1,17 +1,19 @@
+import { readFileSync } from "node:fs";
 import { randomUUID } from "node:crypto";
 import { lstat } from "node:fs/promises";
 import { homedir } from "node:os";
-import { join, resolve } from "node:path";
+import { dirname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
 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.*",
@@ -46,10 +48,16 @@ export const CONFIG_FRAGMENTS = [
     },
     {
         name: "skills-state-permissions",
-        description: "Allow the canonical ~/.agents/skills tree and legacy skills state paths without per-run prompts",
+        description: "Allow the standard skills XDG 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",
@@ -64,7 +72,7 @@ export const CONFIG_FRAGMENTS = [
     },
     {
         name: "tui-schema",
-        description: "Configure terminal settings: OpenCode V2 cli.json or Kilo/MiMo TUI files",
+        description: "Unify each agent TUI file: schema, theme, stacked diffs, and leader keybinds",
         targets: ["opencode", "kilo", "mimo"],
         file: "tui",
     },
@@ -129,26 +137,23 @@ const UNIFIED_TUI_KEYBINDS = {
     messages_toggle_conceal: "<leader>h,<leader>р",
     tips_toggle: "<leader>h,<leader>р",
 };
-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>к",
+const LSP_SERVER_COMMANDS = {
+    python: ["basedpyright-langserver", "--stdio"],
+    typescript: ["typescript-language-server", "--stdio"],
+    yaml: ["yaml-language-server", "--stdio"],
+    shell: ["bash-language-server", "start"],
 };
+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" &&
@@ -166,20 +171,20 @@ function fragmentEdits(fragment, target, current) {
         ? value.permission
         : {};
     if (fragment === "core-plugin") {
-        return corePluginEdits(value);
+        return [
+            { kind: "set-if-absent", path: ["$schema"], value: "https://opencode.ai/config.json" },
+            { kind: "set-if-absent", path: ["plugin"], value: [] },
+            {
+                kind: "replace-array-value",
+                path: ["plugin"],
+                from: LEGACY_PACKAGE_NAME,
+                to: PACKAGE_NAME,
+            },
+            { kind: "append-unique", path: ["plugin"], value: PACKAGE_NAME },
+        ];
     }
     if (fragment === "skills-state-permissions") {
-        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" },
-            ]);
+        const statePaths = target === "opencode" ? [XDG_STATE_GLOB, OPENCODE_SKILLS_GLOB] : [XDG_STATE_GLOB];
         const edits = [];
         if (!mapAllowsAll(permission.read))
             edits.push(...permissionMapEdits(["permission", "read"], Object.fromEntries(statePaths.map((glob) => [glob, "allow"]))));
@@ -189,15 +194,14 @@ 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"], {
@@ -215,18 +219,8 @@ 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: undefined,
+        opencode: "https://opencode.ai/tui.json",
         kilo: undefined,
         mimo: "https://mimo.xiaomi.com/mimocode/tui.json",
     };
@@ -314,9 +308,9 @@ async function resolveTargetFile(target, scope, cwd, home, kind = "main") {
         return {
             target,
             root: globalRoot,
-            path: "cli.json",
-            absolute: join(globalRoot, "cli.json"),
-            exists: await existing(globalRoot, "cli.json"),
+            path: "tui.json",
+            absolute: join(globalRoot, "tui.json"),
+            exists: await existing(globalRoot, "tui.json"),
         };
     }
     if (target === "opencode") {
@@ -410,20 +404,6 @@ 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);
@@ -594,8 +574,6 @@ 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/doctor.d.ts

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

package/dist/doctor.js

@@ -12,7 +12,6 @@ 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);
@@ -115,19 +114,17 @@ function agentManifestValid(raw) {
 }
 function redactedConfig(value) {
     const object = value && typeof value === "object" && !Array.isArray(value) ? value : {};
-    const configuredPlugins = object.plugins;
-    const rawPlugins = Array.isArray(configuredPlugins)
-        ? configuredPlugins.flatMap((item) => {
+    const rawPlugins = Array.isArray(object.plugin)
+        ? object.plugin.flatMap((item) => {
             if (typeof item === "string")
                 return [item];
-            if (item && typeof item === "object" && typeof item.package === "string")
-                return [item.package];
+            if (Array.isArray(item) && typeof item[0] === "string")
+                return [item[0]];
             return [];
         })
         : [];
     const knownPlugins = new Set([packageName, ...CATALOG.plugins]);
-    const normalizePlugin = (plugin) => plugin === packageName || plugin.startsWith(`${packageName}@`) ? packageName : plugin;
-    const plugins = rawPlugins.map(normalizePlugin).filter((plugin) => knownPlugins.has(plugin));
+    const plugins = rawPlugins.filter((plugin) => knownPlugins.has(plugin));
     const enabled = plugins.filter((plugin) => plugin === packageName ||
         CATALOG.plugins.includes(plugin));
     return {
@@ -138,14 +135,17 @@ function redactedConfig(value) {
         keys: Object.keys(object)
             .filter((key) => [
             "$schema",
-            "commands",
+            "theme",
+            "keybinds",
+            "logLevel",
+            "command",
             "watcher",
-            "plugins",
+            "plugin",
             "lsp",
             "formatter",
-            "providers",
-            "agents",
-            "permissions",
+            "provider",
+            "agent",
+            "permission",
             "compaction",
             "model",
         ].includes(key))
@@ -155,26 +155,12 @@ function redactedConfig(value) {
 }
 async function localConfig(scope, cwd, home) {
     const paths = scope === "project"
-        ? [
-            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"),
-        ];
+        ? [join(cwd, "opencode.json"), join(cwd, ".opencode", "opencode.json")]
+        : [join(home, ".config", "opencode", "opencode.json")];
     for (const path of paths) {
         const value = await regular(path);
         if (value.status === "present") {
-            let parsed;
-            try {
-                parsed = parseJsonc(value.raw.toString("utf8"));
-            }
-            catch {
-                parsed = undefined;
-            }
+            const parsed = json(value.raw);
             return parsed
                 ? { projection: redactedConfig(parsed), source: path }
                 : { incomplete: true, source: path };
@@ -264,7 +250,7 @@ async function executableAvailable(name) {
     }
     return false;
 }
-async function lspFacts(project, partial) {
+async function lspFacts(project, host, partial) {
     const suffixes = new Set();
     let scanIncomplete = false;
     const visit = async (root) => {
@@ -291,6 +277,7 @@ async function lspFacts(project, 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);
@@ -298,20 +285,48 @@ async function lspFacts(project, partial) {
         return {
             name: server.name,
             applicable,
-            configured: false,
+            configured: applicable,
             binary_available: available,
-            active: false,
-            runtime_status: "unsupported",
+            active: applicable && available && !disabled,
+            runtime_status: "unavailable",
             requirement_class: server.requirement_class,
-            reason: "unsupported-in-opencode-v2",
+            reason: !applicable
+                ? "not-selected"
+                : disabled
+                    ? "download-disabled"
+                    : !available
+                        ? "missing-dependency"
+                        : "available",
             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,
-        runtime_status: "unsupported",
+        download_disabled: disabled,
+        runtime_status: runtimeStatus,
         servers,
     };
 }
@@ -476,7 +491,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 plugins array entry.",
+        "Local plugin wrappers in the deployment plugins directory load automatically without a plugin array entry.",
     ]));
     const wired = (config.projection?.enabled_plugins ?? []).includes(packageName) ||
         (hostConfig?.enabled_plugins ?? []).includes(packageName);
@@ -608,7 +623,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"].map(async (name) => {
+    const tools = await Promise.all(["opencode", ...lspCatalog.servers.map((server) => server.executable)].map(async (name) => {
         try {
             const result = await run(name, ["--version"], { timeout: 1000 });
             return {
@@ -625,7 +640,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, partial);
+    const lsp = await lspFacts(project, host, 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,15 +1,123 @@
-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";
+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";
 export { rulesInjector, rtk, zedBell };
 export type OpenCodeOptions = {
     rulesInjector?: RulesInjectorOptions;
     rtk?: RtkOptions;
     zedBell?: ZedBellOptions;
 };
-declare const _default: {
-    id: string;
-    setup(ctx: Plugin.Context): Promise<void>;
-};
-export default _default;
+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;