litopencode 0.0.3 → 0.0.4

package/README.md

@@ -34,9 +34,9 @@
 
     npx litopencode install
 
-The installer delegates the default install path to OpenCode's own plugin installer and registers a version-pinned entry such as <code>litopencode@0.0.3</code>. Then restart OpenCode. The agent switcher should show <code>lit-plan</code> and <code>lit-loop</code>.
+The installer delegates the default install path to OpenCode's own plugin installer. Published installs register a version-pinned entry such as <code>litopencode@0.0.4</code>; local checkout installs register the local package path for development. Then restart OpenCode. The agent switcher should show <code>lit-plan</code> and <code>lit-loop</code>.
 
-For a preview without writing <code>opencode.json</code>:
+For a preview without writing OpenCode config:
 
     npx litopencode install --dry-run
 
@@ -44,7 +44,7 @@ For health checks:
 
     npx litopencode doctor
 
-By default, the installer targets <code>~/.config/opencode/opencode.json</code>, or <code>$XDG_CONFIG_HOME/opencode/opencode.json</code> when <code>XDG_CONFIG_HOME</code> is set. Use <code>--root &lt;dir&gt;</code> for a custom OpenCode config directory.
+By default, OpenCode manages <code>~/.config/opencode/opencode.jsonc</code>, or <code>$XDG_CONFIG_HOME/opencode/opencode.jsonc</code> when <code>XDG_CONFIG_HOME</code> is set. Use <code>--root &lt;dir&gt;</code> for a custom OpenCode config directory; custom roots use a direct <code>opencode.json</code> patch for deterministic tests and previews.
 
 ### Local Source Probe
 

package/dist/agents/registry.js

@@ -11,20 +11,37 @@ function toolsToConfig(tools) {
     }
     return enabledTools;
 }
+function toolsToPermission(tools) {
+    const permission = {};
+    if (tools.includes("edit") || tools.includes("write"))
+        permission.edit = "allow";
+    if (tools.includes("bash"))
+        permission.bash = "allow";
+    if (tools.includes("webfetch"))
+        permission.webfetch = "allow";
+    return Object.keys(permission).length > 0 ? permission : undefined;
+}
 export function toOpenCodeAgentConfig(agent) {
     return {
         description: agent.summary,
         prompt: agent.prompt,
-        mode: agent.mode,
+        mode: agent.mode === "primary" ? "all" : "subagent",
         tools: toolsToConfig(agent.tools),
         color: agent.color,
-        maxSteps: agent.maxSteps
+        maxSteps: agent.maxSteps,
+        ...(agent.mode === "subagent" ? { hidden: true } : {}),
+        ...(toolsToPermission(agent.tools) ? { permission: toolsToPermission(agent.tools) } : {})
     };
 }
 export function registerLitOpenCodeAgents(config) {
+    const existingBuild = config.agent?.build ?? {};
+    const existingPlan = config.agent?.plan ?? {};
     config.agent = {
-        ...config.agent
+        ...config.agent,
+        build: { ...existingBuild, mode: "subagent", hidden: true },
+        plan: { ...existingPlan, mode: "subagent", hidden: true }
     };
+    config.default_agent = "lit-loop";
     for (const agent of litOpenCodeAgents) {
         config.agent[agent.id] = toOpenCodeAgentConfig(agent);
     }

package/dist/agents/types.d.ts

@@ -1,7 +1,9 @@
 import type { Config } from "@opencode-ai/plugin";
 export type AgentTier = "default" | "role" | "specialist";
 export type AgentMode = "primary" | "subagent";
+export type OpenCodeAgentMode = "all" | "subagent";
 export type AgentToolId = "read" | "write" | "edit" | "bash" | "webfetch" | "grep";
+export type AgentPermission = "ask" | "allow" | "deny";
 export type LitOpenCodeAgent = {
     readonly id: string;
     readonly name: string;
@@ -18,12 +20,20 @@ export type LitOpenCodeAgent = {
 export type OpenCodeAgentConfig = {
     readonly description: string;
     readonly prompt: string;
-    readonly mode: AgentMode;
+    readonly mode: OpenCodeAgentMode;
     readonly tools: Record<string, boolean>;
     readonly color: string;
     readonly maxSteps: number;
+    readonly hidden?: boolean;
+    readonly permission?: {
+        readonly edit?: AgentPermission;
+        readonly bash?: AgentPermission;
+        readonly webfetch?: AgentPermission;
+    };
+};
+export type AgentConfigTarget = Pick<Config, "agent"> & {
+    default_agent?: string;
 };
-export type AgentConfigTarget = Pick<Config, "agent">;
 export declare const planningTools: readonly ("read" | "grep")[];
 export declare const workerTools: readonly ("read" | "write" | "edit" | "bash" | "grep")[];
 export declare const reviewTools: readonly ("read" | "bash" | "grep")[];

package/dist/cli/args.js

@@ -49,7 +49,7 @@ export function helpText() {
         "  litopencode doctor [--root <dir>]",
         "",
         "Commands:",
-        "  install       Add litopencode to opencode.json with a branded installer UI.",
+        "  install       Register litopencode with OpenCode using a branded installer UI.",
         "  doctor        Report package, config, and runtime path status without writing files.",
         "",
         "Default root:",

package/dist/cli/install.js

@@ -37,20 +37,98 @@ function defaultOpenCodeRoot() {
 function shouldUseOpenCodeInstaller(root) {
     return path.resolve(root) === path.resolve(defaultOpenCodeRoot());
 }
+function openCodeConfigCandidates(root) {
+    const resolvedRoot = path.resolve(root);
+    return [path.join(resolvedRoot, "opencode.json"), path.join(resolvedRoot, "opencode.jsonc")];
+}
+async function openCodeManagedConfigFile(root) {
+    const [jsonFile, jsoncFile] = openCodeConfigCandidates(root);
+    if (await pathExists(jsonFile))
+        return jsonFile;
+    if (await pathExists(jsoncFile))
+        return jsoncFile;
+    return jsoncFile;
+}
+function outputText(value) {
+    if (typeof value === "string")
+        return value;
+    if (value instanceof Uint8Array)
+        return Buffer.from(value).toString("utf8");
+    return "";
+}
+function stripAnsi(value) {
+    return value.replace(/\u001b\[[0-9;?]*[ -/]*[@-~]/g, "");
+}
+function commandFailureDetail(error) {
+    if (!(error instanceof Error))
+        return String(error);
+    const failure = error;
+    const parts = [];
+    const stderr = stripAnsi(outputText(failure.stderr)).trim();
+    const stdout = stripAnsi(outputText(failure.stdout)).trim();
+    const code = typeof failure.code === "number" || typeof failure.code === "string" ? String(failure.code) : "";
+    const signal = typeof failure.signal === "string" ? failure.signal : "";
+    if (stderr.length > 0)
+        parts.push("stderr:\n" + stderr);
+    if (stdout.length > 0)
+        parts.push("stdout:\n" + stdout);
+    if (code.length > 0)
+        parts.push("exit code: " + code);
+    if (signal.length > 0)
+        parts.push("signal: " + signal);
+    if (parts.length === 0 && error.message.length > 0)
+        parts.push(error.message);
+    return parts.join("\n\n");
+}
+async function pathExists(filePath) {
+    try {
+        await fs.stat(filePath);
+        return true;
+    }
+    catch (error) {
+        if (error instanceof Error && "code" in error && error.code === "ENOENT")
+            return false;
+        throw error;
+    }
+}
+async function isLocalSourcePackage(packageRoot) {
+    const realPackageRoot = await fs.realpath(packageRoot);
+    return (await pathExists(path.join(realPackageRoot, ".git"))) && (await pathExists(path.join(realPackageRoot, "src")));
+}
+async function openCodeInstallTarget(metadata) {
+    if (await isLocalSourcePackage(metadata.packageRoot)) {
+        const realPackageRoot = await fs.realpath(metadata.packageRoot);
+        return { value: realPackageRoot, label: metadata.name + "@" + metadata.version + " (local checkout)" };
+    }
+    const spec = pluginSpec(metadata);
+    return { value: spec, label: spec };
+}
 async function installWithOpenCode(target) {
     try {
-        await execFileAsync("opencode", ["plugin", target, "--global", "--force"], {
+        await execFileAsync("opencode", ["plugin", target.value, "--global", "--force"], {
             timeout: 120_000,
             maxBuffer: 1024 * 1024 * 4
         });
     }
     catch (error) {
-        const detail = error instanceof Error && "stderr" in error && typeof error.stderr === "string"
-            ? error.stderr.trim()
-            : error instanceof Error
-                ? error.message
-                : String(error);
-        throw new Error("OpenCode plugin install failed for " + target + (detail ? ":\n" + detail : ""));
+        const detail = commandFailureDetail(error);
+        throw new Error("OpenCode plugin install failed for " + target.label + (detail ? ":\n" + detail : ""));
+    }
+}
+async function removeStaleOpenCodeEntries(root, target) {
+    for (const configFile of openCodeConfigCandidates(root)) {
+        const config = await readJsonObjectIfPresent(configFile);
+        const pluginValue = config?.plugin;
+        if (!Array.isArray(pluginValue))
+            continue;
+        const nextPlugin = pluginValue.filter((entry) => {
+            if (entry === target.value)
+                return true;
+            return !isLitOpenCodeEntry(entry);
+        });
+        if (nextPlugin.length === pluginValue.length)
+            continue;
+        await fs.writeFile(configFile, JSON.stringify({ ...config, plugin: nextPlugin }, null, 2) + "\n");
     }
 }
 function describePluginMutation(config, target) {
@@ -135,25 +213,29 @@ function renderInstallReport(report) {
 export async function install(root, dryRun) {
     const metadata = await readPackageMetadata();
     const paths = createRuntimePaths(root);
-    const before = await readJsonObjectIfPresent(paths.opencodeConfigFile);
-    const target = pluginSpec(metadata);
-    const mutation = describePluginMutation(before, target);
+    const useOpenCodeInstaller = shouldUseOpenCodeInstaller(root);
+    const configFile = useOpenCodeInstaller ? await openCodeManagedConfigFile(root) : paths.opencodeConfigFile;
+    const before = useOpenCodeInstaller ? null : await readJsonObjectIfPresent(paths.opencodeConfigFile);
+    const spec = pluginSpec(metadata);
+    const target = useOpenCodeInstaller ? await openCodeInstallTarget(metadata) : { value: spec, label: spec };
+    const mutation = describePluginMutation(before, target.value);
     const report = {
         dryRun,
-        path: paths.opencodeConfigFile,
+        path: configFile,
         plugin: mutation.plugin,
         patch: mutation.patch,
         changed: mutation.changed,
-        package: metadata
+        package: { name: metadata.name, version: metadata.version }
     };
     if (dryRun) {
         return { exitCode: 0, stdout: JSON.stringify(report, null, 2) };
     }
-    if (shouldUseOpenCodeInstaller(root)) {
+    if (useOpenCodeInstaller) {
+        await removeStaleOpenCodeEntries(root, target);
         await installWithOpenCode(target);
     }
     else if (mutation.changed) {
-        const next = applyPluginMutation(before, mutation, target);
+        const next = applyPluginMutation(before, mutation, target.value);
         await fs.mkdir(path.dirname(paths.opencodeConfigFile), { recursive: true });
         await fs.writeFile(paths.opencodeConfigFile, JSON.stringify(next, null, 2) + "\n");
     }

package/dist/cli/json.js

@@ -5,12 +5,13 @@ export function isRecord(value) {
     return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 export async function readPackageMetadata() {
-    const packagePath = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "../../package.json");
+    const packageRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "../..");
+    const packagePath = path.join(packageRoot, "package.json");
     const parsed = JSON.parse(await fs.readFile(packagePath, "utf8"));
     if (!isRecord(parsed) || typeof parsed.name !== "string" || typeof parsed.version !== "string") {
         throw new Error(`Malformed package metadata at ${packagePath}`);
     }
-    return { name: parsed.name, version: parsed.version };
+    return { name: parsed.name, version: parsed.version, packageRoot };
 }
 export async function readJsonObjectIfPresent(filePath) {
     let raw;

package/dist/cli/types.d.ts

@@ -6,6 +6,7 @@ export type CliResult = {
 export type PackageMetadata = {
     readonly name: string;
     readonly version: string;
+    readonly packageRoot: string;
 };
 export type ParsedArgs = {
     readonly command?: string;
@@ -45,5 +46,5 @@ export type InstallReport = {
     readonly plugin: PluginMutation["plugin"];
     readonly patch: readonly JsonPatchOperation[];
     readonly changed: boolean;
-    readonly package: PackageMetadata;
+    readonly package: Pick<PackageMetadata, "name" | "version">;
 };

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-import type { Hooks, PluginInput } from "@opencode-ai/plugin";
+import litOpenCodePlugin from "./server.ts";
 export { appendLedgerEvent, createLitGoalOperations, initializeLitGoal, readLedgerEvents, recoverLedgerTemps, LedgerIoError, LedgerParseError, type JsonValue, type LedgerAppendResult, type LedgerEvent, type LedgerRecoveryReport, type LitGoalInitialization, type LitGoalOperations } from "./ledger.ts";
 export { litActivationBanner, litOpenCodeCommands } from "./commands.ts";
 export { createToolExecuteAfterHook, createToolExecuteBeforeHook } from "./hooks.ts";
@@ -7,9 +7,8 @@ export { litOpenCodeTools, litTool, litworkTool } from "./tools.ts";
 export { findLitOpenCodeFeature, litOpenCodeFeatures, type LitOpenCodeBindingKind, type LitOpenCodeFeature, type LitOpenCodeFeatureBinding, type LitOpenCodeFeatureId } from "./features.ts";
 export { findLitOpenCodeRuntimeSkill, litOpenCodeRuntimeSkills, type LitOpenCodeRuntimeSkill, type LitOpenCodeRuntimeSkillId } from "./skills.ts";
 export declare const pluginId = "litopencode";
-declare const litOpenCodePlugin: (input?: PluginInput) => Promise<Hooks>;
 export declare const pluginModule: {
     id: string;
-    server: (input?: PluginInput) => Promise<Hooks>;
+    server: (input?: import("@opencode-ai/plugin").PluginInput) => Promise<import("@opencode-ai/plugin").Hooks>;
 };
 export default litOpenCodePlugin;

package/dist/index.js

@@ -1,10 +1,5 @@
-import { registerLitOpenCodeAgents } from "./agents.js";
-import { createCommandActivationHook, litActivationBanner, litOpenCodeCommands } from "./commands.js";
-import { loadConfig } from "./config.js";
-import { createToolExecuteAfterHook, createToolExecuteBeforeHook } from "./hooks.js";
+import litOpenCodePlugin from "./server.js";
 export { appendLedgerEvent, createLitGoalOperations, initializeLitGoal, readLedgerEvents, recoverLedgerTemps, LedgerIoError, LedgerParseError } from "./ledger.js";
-import { createLogger } from "./logger.js";
-import { litOpenCodeTools } from "./tools.js";
 export { litActivationBanner, litOpenCodeCommands } from "./commands.js";
 export { createToolExecuteAfterHook, createToolExecuteBeforeHook } from "./hooks.js";
 export { applyLitOpenCodeToolAfterHook, applyLitOpenCodeToolBeforeHook } from "./tool-guards.js";
@@ -12,32 +7,6 @@ export { litOpenCodeTools, litTool, litworkTool } from "./tools.js";
 export { findLitOpenCodeFeature, litOpenCodeFeatures } from "./features.js";
 export { findLitOpenCodeRuntimeSkill, litOpenCodeRuntimeSkills } from "./skills.js";
 export const pluginId = "litopencode";
-const litOpenCodePlugin = async (input) => {
-    const root = input?.worktree ?? input?.directory ?? ".";
-    const loaded = await loadConfig(root);
-    const logger = createLogger(loaded.paths);
-    const hooks = {
-        config: async (config) => {
-            registerLitOpenCodeAgents(config);
-        },
-        tool: litOpenCodeTools,
-        "command.execute.before": createCommandActivationHook(root),
-        dispose: async () => {
-            await logger.dispose();
-        }
-    };
-    Object.defineProperties(hooks, {
-        "tool.execute.before": {
-            value: createToolExecuteBeforeHook(),
-            enumerable: false
-        },
-        "tool.execute.after": {
-            value: createToolExecuteAfterHook(),
-            enumerable: false
-        }
-    });
-    return hooks;
-};
 export const pluginModule = {
     id: pluginId,
     server: litOpenCodePlugin

package/dist/server.d.ts

@@ -0,0 +1,3 @@
+import type { Hooks, PluginInput } from "@opencode-ai/plugin";
+declare const litOpenCodePlugin: (input?: PluginInput) => Promise<Hooks>;
+export default litOpenCodePlugin;

package/dist/server.js

@@ -0,0 +1,33 @@
+import { registerLitOpenCodeAgents } from "./agents.js";
+import { createCommandActivationHook } from "./commands.js";
+import { loadConfig } from "./config.js";
+import { createToolExecuteAfterHook, createToolExecuteBeforeHook } from "./hooks.js";
+import { createLogger } from "./logger.js";
+import { litOpenCodeTools } from "./tools.js";
+const litOpenCodePlugin = async (input) => {
+    const root = input?.worktree ?? input?.directory ?? ".";
+    const loaded = await loadConfig(root);
+    const logger = createLogger(loaded.paths);
+    const hooks = {
+        config: async (config) => {
+            registerLitOpenCodeAgents(config);
+        },
+        tool: litOpenCodeTools,
+        "command.execute.before": createCommandActivationHook(root),
+        dispose: async () => {
+            await logger.dispose();
+        }
+    };
+    Object.defineProperties(hooks, {
+        "tool.execute.before": {
+            value: createToolExecuteBeforeHook(),
+            enumerable: false
+        },
+        "tool.execute.after": {
+            value: createToolExecuteAfterHook(),
+            enumerable: false
+        }
+    });
+    return hooks;
+};
+export default litOpenCodePlugin;

package/dist/skills.js

@@ -40,6 +40,7 @@ export const litOpenCodeRuntimeSkills = Object.freeze([
         discovery: "Run npx litopencode install, litopencode doctor, or litopencode install --dry-run.",
         safety: [
             "Default installation delegates to the OpenCode plugin installer; custom roots write only the version-pinned opencode.json plugin entry.",
+            "Local checkout installs hand OpenCode the package path so unpublished versions can be tested before npm publish.",
             "Malformed config fails closed with a typed config error."
         ]
     },

package/docs/migration.md

@@ -11,9 +11,9 @@ This guide describes the supported migration shape for moving an OpenCode workfl
 ## Environment And Config
 
 - Use the `LITOPENCODE_` prefix for LitOpenCode-owned environment variables.
-- Keep OpenCode plugin configuration in `opencode.json`.
+- Keep default OpenCode plugin configuration in OpenCode's managed `opencode.jsonc`; custom-root LitOpenCode previews use `opencode.json`.
 - Keep LitOpenCode runtime config in `.litopencode/config.json` when project-local config is needed.
-- Use `npx litopencode install` to delegate default setup to `opencode plugin litopencode@0.0.3 --global --force` and register the version-pinned plugin entry.
+- Use `npx litopencode install` to delegate default setup to `opencode plugin <target> --global --force`; published installs use `litopencode@0.0.4`, while local checkout installs use the package path.
 - Use `litopencode doctor --root <workspace>` to inspect package metadata, config source, runtime paths, and ledger location without writing files.
 - Use `litopencode install --dry-run --root <workspace>` to preview the `opencode.json` plugin mutation without writing files.
 

package/docs/release-checklist.md

@@ -41,7 +41,7 @@ After the source gates pass, verify the packed artifact in a temporary directory
 ```sh
 tmp="$(mktemp -d)"
 npm pack --pack-destination "$tmp"
-tar -xzf "$tmp"/litopencode-0.0.3.tgz -C "$tmp"
+tar -xzf "$tmp"/litopencode-0.0.4.tgz -C "$tmp"
 node --input-type=module -e "import('$tmp/package/dist/index.js').then((m) => console.log(m.default?.id ?? m.pluginId))"
 (
   cd "$tmp/package"
@@ -73,7 +73,7 @@ mkdir "$tmp/consumer"
 (
   cd "$tmp/consumer"
   npm init -y
-  npm install "$tmp"/litopencode-0.0.3.tgz
+  npm install "$tmp"/litopencode-0.0.4.tgz
   npm ls litopencode --all
   node --input-type=module -e "import('litopencode').then((m) => console.log(m.default.id))"
   node_modules/.bin/litopencode --help
@@ -89,7 +89,7 @@ Expected results:
 - `@opencode-ai/plugin` is declared as an optional peer for TypeScript host typings without forcing npx/global installs to pull its transitive runtime tree
 - package import prints `litopencode`
 - CLI help, doctor, install dry-run, and write-enabled install exit 0
-- write-enabled install creates or updates `opencode.json` without echoing unrelated config secrets
+- write-enabled custom-root install creates or updates `opencode.json` without echoing unrelated config secrets
 - temporary project cleanup removes the probe directory
 
 ## OpenCode Host Probe

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "litopencode",
-  "version": "0.0.3",
+  "version": "0.0.4",
   "description": "LitOpenCode OpenCode plugin bootstrap package.",
   "type": "module",
   "bin": {
@@ -13,8 +13,8 @@
       "import": "./dist/index.js"
     },
     "./server": {
-      "types": "./dist/index.d.ts",
-      "import": "./dist/index.js"
+      "types": "./dist/server.d.ts",
+      "import": "./dist/server.js"
     }
   },
   "scripts": {