@litfamily/litopencode 1.0.18 → 1.0.20

package/dist/cli/plugin-mutation.js

@@ -9,18 +9,23 @@ function pluginEntryId(value) {
         return value[0];
     return "";
 }
+// The install target counts as a LitOpenCode entry even when it is a local checkout path, which the
+// package-name match cannot recognize; otherwise a re-install would append the same path again.
+function isRegistrationEntry(value, target) {
+    return isLitOpenCodeEntry(value) || pluginEntryId(value) === target;
+}
 function replaceLitOpenCodeEntry(value, target) {
-    if (Array.isArray(value) && isLitOpenCodeEntry(value))
+    if (Array.isArray(value))
         return [target, ...value.slice(1)];
     return target;
 }
 function normalizedPluginArray(pluginValue, target) {
-    const firstLitEntry = pluginValue.find(isLitOpenCodeEntry);
+    const firstLitEntry = pluginValue.find((value) => isRegistrationEntry(value, target));
     const replacement = firstLitEntry === undefined ? target : replaceLitOpenCodeEntry(firstLitEntry, target);
     let replaced = false;
     const next = [];
     for (const value of pluginValue) {
-        if (!isLitOpenCodeEntry(value)) {
+        if (!isRegistrationEntry(value, target)) {
             next.push(value);
             continue;
         }
@@ -34,9 +39,9 @@ function normalizedPluginArray(pluginValue, target) {
 export function describePluginMutation(config, target) {
     const pluginValue = config?.plugin;
     const pluginIsArray = Array.isArray(pluginValue);
-    const existingIndex = pluginIsArray ? pluginValue.findIndex(isLitOpenCodeEntry) : -1;
+    const existingIndex = pluginIsArray ? pluginValue.findIndex((value) => isRegistrationEntry(value, target)) : -1;
     const targetIndex = pluginIsArray ? pluginValue.findIndex((value) => pluginEntryId(value) === target) : -1;
-    const litEntryCount = pluginIsArray ? pluginValue.filter(isLitOpenCodeEntry).length : 0;
+    const litEntryCount = pluginIsArray ? pluginValue.filter((value) => isRegistrationEntry(value, target)).length : 0;
     const alreadyPresent = targetIndex >= 0 && litEntryCount === 1;
     const currentCount = pluginIsArray ? pluginValue.length : 0;
     if (alreadyPresent) {
@@ -81,7 +86,7 @@ export function applyPluginMutation(config, mutation, target) {
         return next;
     const pluginValue = next.plugin;
     if (Array.isArray(pluginValue)) {
-        next.plugin = pluginValue.some(isLitOpenCodeEntry) ? normalizedPluginArray(pluginValue, target) : [...pluginValue, target];
+        next.plugin = pluginValue.some((value) => isRegistrationEntry(value, target)) ? normalizedPluginArray(pluginValue, target) : [...pluginValue, target];
         return next;
     }
     next.plugin = [target];

package/dist/cli/tui-config.d.ts

@@ -0,0 +1,52 @@
+export declare const tuiSchemaUrl = "https://opencode.ai/tui.json";
+export declare const tuiBackupSuffix = ".litopencode-backup";
+type PlannedWrite = {
+    readonly path: string;
+    readonly before: string | null;
+    readonly text: string;
+};
+export type TuiInstallReport = {
+    readonly path: string;
+    readonly alreadyPresent: boolean;
+    readonly changed: boolean;
+    readonly add: readonly string[];
+    readonly currentCount: number;
+    readonly resultCount: number;
+    readonly cleaned: readonly string[];
+};
+export type TuiInstallPlan = {
+    readonly report: TuiInstallReport;
+    readonly writes: readonly PlannedWrite[];
+    readonly blocked?: string;
+};
+export type TuiRemovalReport = {
+    readonly dryRun: boolean;
+    readonly removed: number;
+    readonly files: readonly {
+        readonly path: string;
+        readonly removed: number;
+        readonly backup?: string;
+    }[];
+};
+export declare function tuiConfigCandidates(root: string): readonly [string, string];
+/** Works out every TUI config edit an install makes, without writing. A comment that would be lost blocks the plan. */
+export declare function planTuiInstall(root: string, target: string): Promise<TuiInstallPlan>;
+/** Writes a plan: each file that already existed is copied to `<file>.litopencode-backup` first. */
+export declare function applyTuiWrites(writes: readonly PlannedWrite[], options?: {
+    readonly backup?: boolean;
+}): Promise<void>;
+/** Backs up the TUI files a plan is about to change, for writers outside LitOpenCode such as `opencode plugin`. */
+export declare function backupTuiFiles(plan: TuiInstallPlan): Promise<void>;
+/** Removes LitOpenCode's own TUI entries, and only those, from tui.json and tui.jsonc. */
+export declare function removeTuiPlugin(root: string, dryRun: boolean): Promise<TuiRemovalReport>;
+export type TuiInspection = {
+    readonly path: string;
+    readonly expected: string;
+    readonly configured: string | null;
+    readonly present: boolean;
+    readonly entries: number;
+    readonly ok: boolean;
+    readonly error?: string;
+};
+export declare function inspectTuiPlugin(root: string, expected: string): Promise<TuiInspection>;
+export {};

package/dist/cli/tui-config.js

@@ -0,0 +1,198 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { OpenCodeConfigCommentError, renderOpenCodeConfig, writeTextAtomically } from "./install-config.js";
+import { isRecord, readJsonObjectIfPresent, readTextIfPresent } from "./json.js";
+import { parseJsonc } from "./jsonc.js";
+import { isLitOpenCodeEntry } from "./plugin-mutation.js";
+// OpenCode reads TUI plugins from the `plugin` list of tui.json and tui.jsonc beside opencode.json,
+// merging both. When it adds an entry itself it edits the first of the two that exists, else creates
+// tui.json; LitOpenCode follows the same choice so a host install and ours never split the entry.
+export const tuiSchemaUrl = "https://opencode.ai/tui.json";
+export const tuiBackupSuffix = ".litopencode-backup";
+export function tuiConfigCandidates(root) {
+    const resolved = path.resolve(root);
+    return [path.join(resolved, "tui.json"), path.join(resolved, "tui.jsonc")];
+}
+function entryId(value) {
+    if (typeof value === "string")
+        return value;
+    if (Array.isArray(value) && typeof value[0] === "string")
+        return value[0];
+    return "";
+}
+async function isLitOpenCodePathEntry(root, id) {
+    if (!(path.isAbsolute(id) || id.startsWith(".")))
+        return false;
+    const metadata = await readJsonObjectIfPresent(path.join(path.resolve(root, id), "package.json")).catch(() => null);
+    return metadata?.name === "litopencode" || metadata?.name === "@litfamily/opencode" || metadata?.name === "@litfamily/litopencode";
+}
+async function isOwnEntry(root, value, target) {
+    const id = entryId(value);
+    return id !== "" && (id === target || isLitOpenCodeEntry(value) || (await isLitOpenCodePathEntry(root, id)));
+}
+async function readTuiFile(file) {
+    const text = await readTextIfPresent(file);
+    if (text === null)
+        return { path: file, text, config: null };
+    let parsed;
+    try {
+        parsed = parseJsonc(text);
+    }
+    catch (error) {
+        throw new Error(`Malformed JSONC at ${file}: ${error instanceof Error ? error.message : String(error)}. Nothing was written.`);
+    }
+    if (!isRecord(parsed))
+        throw new Error(`Malformed JSON at ${file}: expected an object. Nothing was written.`);
+    return { path: file, text, config: parsed };
+}
+async function ownIndexes(root, plugins, target) {
+    const indexes = [];
+    for (const [index, value] of plugins.entries())
+        if (await isOwnEntry(root, value, target))
+            indexes.push(index);
+    return indexes;
+}
+function pluginList(config) {
+    return Array.isArray(config?.plugin) ? config.plugin : [];
+}
+function render(file, next) {
+    return { path: file.path, before: file.text, text: renderOpenCodeConfig(file.path, file.text, next) };
+}
+/** Works out every TUI config edit an install makes, without writing. A comment that would be lost blocks the plan. */
+export async function planTuiInstall(root, target) {
+    const files = await Promise.all(tuiConfigCandidates(root).map(readTuiFile));
+    const owned = await Promise.all(files.map(async (file) => ownIndexes(root, pluginList(file.config), target)));
+    const holder = files.findIndex((_file, index) => owned[index].length > 0);
+    const primaryIndex = holder >= 0 ? holder : Math.max(0, files.findIndex((file) => file.text !== null));
+    const primary = files[primaryIndex];
+    const current = pluginList(primary.config);
+    const primaryOwned = owned[primaryIndex];
+    const alreadyPresent = primaryOwned.length === 1 && entryId(current[primaryOwned[0]]) === target;
+    let nextPlugins;
+    if (primaryOwned.length === 0) {
+        nextPlugins = [...current, target];
+    }
+    else {
+        const first = current[primaryOwned[0]];
+        const replacement = Array.isArray(first) ? [target, ...first.slice(1)] : target;
+        nextPlugins = current.flatMap((value, index) => (index === primaryOwned[0] ? [replacement] : primaryOwned.includes(index) ? [] : [value]));
+    }
+    const writes = [];
+    const cleaned = [];
+    try {
+        if (JSON.stringify(nextPlugins) !== JSON.stringify(current) || primary.config === null) {
+            const base = primary.config === null ? { $schema: tuiSchemaUrl } : primary.config;
+            writes.push(render(primary, { ...base, plugin: nextPlugins }));
+        }
+        for (const [index, file] of files.entries()) {
+            if (index === primaryIndex || owned[index].length === 0 || file.config === null)
+                continue;
+            const kept = pluginList(file.config).filter((_value, position) => !owned[index].includes(position));
+            writes.push(render(file, { ...file.config, plugin: kept }));
+            cleaned.push(file.path);
+        }
+    }
+    catch (error) {
+        if (!(error instanceof OpenCodeConfigCommentError))
+            throw error;
+        return { report: { ...report(), changed: true, add: [target] }, writes: [], blocked: error.message };
+    }
+    return { report: report(), writes };
+    function report() {
+        const changed = writes.length > 0;
+        return {
+            path: primary.path,
+            alreadyPresent,
+            changed,
+            add: changed ? [target] : [],
+            currentCount: current.length,
+            resultCount: nextPlugins.length,
+            cleaned
+        };
+    }
+}
+async function backup(write) {
+    if (write.before === null)
+        return undefined;
+    const file = write.path + tuiBackupSuffix;
+    await writeTextAtomically(file, write.before);
+    return file;
+}
+/** Writes a plan: each file that already existed is copied to `<file>.litopencode-backup` first. */
+export async function applyTuiWrites(writes, options = {}) {
+    for (const write of writes) {
+        if (options.backup !== false)
+            await backup(write);
+        await fs.mkdir(path.dirname(write.path), { recursive: true });
+        await writeTextAtomically(write.path, write.text);
+    }
+}
+/** Backs up the TUI files a plan is about to change, for writers outside LitOpenCode such as `opencode plugin`. */
+export async function backupTuiFiles(plan) {
+    for (const write of plan.writes)
+        await backup(write);
+}
+/** Removes LitOpenCode's own TUI entries, and only those, from tui.json and tui.jsonc. */
+export async function removeTuiPlugin(root, dryRun) {
+    const files = await Promise.all(tuiConfigCandidates(root).map(readTuiFile));
+    const writes = [];
+    for (const file of files) {
+        if (file.config === null)
+            continue;
+        const plugins = pluginList(file.config);
+        const owned = await ownIndexes(root, plugins, undefined);
+        if (owned.length === 0)
+            continue;
+        const kept = plugins.filter((_value, index) => !owned.includes(index));
+        writes.push({ write: render(file, { ...file.config, plugin: kept }), removed: owned.length });
+    }
+    const reports = [];
+    for (const { write, removed } of writes) {
+        if (dryRun) {
+            reports.push({ path: write.path, removed });
+            continue;
+        }
+        const backupPath = await backup(write);
+        await writeTextAtomically(write.path, write.text);
+        reports.push({ path: write.path, removed, ...(backupPath === undefined ? {} : { backup: backupPath }) });
+    }
+    return { dryRun, removed: reports.reduce((total, entry) => total + entry.removed, 0), files: reports };
+}
+export async function inspectTuiPlugin(root, expected) {
+    let files;
+    try {
+        files = await Promise.all(tuiConfigCandidates(root).map(readTuiFile));
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return { path: tuiConfigCandidates(root)[0], expected, configured: null, present: false, entries: 0, ok: false, error: message };
+    }
+    let found;
+    let entries = 0;
+    let present = false;
+    for (const file of files) {
+        for (const value of pluginList(file.config)) {
+            const id = entryId(value);
+            const exact = id === expected || (await isLitOpenCodePathEntry(root, id));
+            if (!exact && !isLitOpenCodeEntry(value))
+                continue;
+            entries += 1;
+            if (exact && !present) {
+                present = true;
+                found = { path: file.path, id };
+            }
+            else if (found === undefined) {
+                found = { path: file.path, id };
+            }
+        }
+    }
+    const fallback = files.find((file) => file.text !== null)?.path ?? files[0].path;
+    return {
+        path: found?.path ?? fallback,
+        expected,
+        configured: found?.id ?? null,
+        present,
+        entries,
+        ok: present && entries === 1
+    };
+}

package/dist/cli/types.d.ts

@@ -1,4 +1,5 @@
 import type { OpenCodeHostCapabilities } from "./host-capabilities.ts";
+import type { TuiInstallReport } from "./tui-config.ts";
 export type CliResult = {
     readonly exitCode: number;
     readonly stdout?: string;
@@ -25,6 +26,7 @@ export type ParsedArgs = {
     readonly modelPrompt: ModelPromptMode;
     readonly outputStylePrompt: PermissionPromptMode;
     readonly loop: LoopArgs;
+    readonly tuiAction?: string;
 };
 export type LoopArgs = {
     readonly projectRoot: string;
@@ -181,8 +183,10 @@ export type InstallReport = {
         readonly compactionTriggerTokens: number;
         readonly compactionReserveTokens: number;
     };
+    readonly tui: TuiInstallReport;
     readonly patch: readonly JsonPatchOperation[];
     readonly changed: boolean;
+    readonly blocked?: string;
     readonly routes?: InstallRouteReport;
     readonly capabilities: OpenCodeHostCapabilities;
     readonly package: Pick<PackageMetadata, "name" | "version">;

package/dist/cli.js

@@ -10,6 +10,7 @@ import { defaultOpenAiRoutes, legacyFastAliasHelp, modelEffortHelp, openaiModelH
 import { fetchPublicSource } from "./lit-fetch.js";
 import { readPackageMetadata } from "./cli/json.js";
 import { runMotionRuntime } from "./cli/motion-runtime.js";
+import { removeTuiPlugin } from "./cli/tui-config.js";
 import path from "node:path";
 import { pathToFileURL } from "node:url";
 function helpText() {
@@ -34,7 +35,8 @@ function helpText() {
         "  litopencode install [--permission-prompt | --no-permission-prompt] [--permission-mode <safe|balanced|yolo>]",
         "  litopencode install|doctor [--no-auto-update]",
         "  litopencode doctor [--json] [--root <dir>]",
-        "  litopencode motion-runtime install|status [--audio] [--word-timing]",
+        "  litopencode tui remove [--dry-run] [--root <dir>]",
+        "  litopencode motion-runtime install|status [--audio] [--word-timing] [--dry-run] (install) [--json] (status)",
         "  litopencode fetch-public <url> [--json] [--timeout <ms>] [--max-bytes <n>]",
         "  litopencode fetch-public <local-url> --json --allow-private-network  # trusted fixtures only",
         "  OpenCode /start-work init|resume|cancel|complete|status <schema-3 JSON>",
@@ -52,6 +54,7 @@ function helpText() {
         "Commands:",
         "  install       Register litopencode with OpenCode using a branded installer UI.",
         "  doctor        Report package, config, and runtime path status without writing files.",
+        "  tui remove    Remove only LitOpenCode's TUI panel entry from tui.json/tui.jsonc (backed up first).",
         "  fetch-public  Fetch a public URL with SSRF guards, verdicts, and trace output.",
         "                --allow-private-network is opt-in for reviewed local fixtures or trusted internal tests.",
         "",
@@ -118,7 +121,7 @@ function helpText() {
 export async function runCli(argv = process.argv.slice(2), options = {}) {
     if (argv[0] === "motion-runtime") {
         const metadata = await readPackageMetadata();
-        return runMotionRuntime(metadata.packageRoot, argv.slice(1));
+        return await runMotionRuntime(metadata.packageRoot, argv.slice(1));
     }
     let parsed;
     try {
@@ -133,9 +136,11 @@ export async function runCli(argv = process.argv.slice(2), options = {}) {
             return { exitCode: 0, stdout: helpText() };
         }
         if (isLoopCommand(parsed.command))
-            return await runLoopCommand(parsed.command, parsed.loop);
+            return await runLoopCommand(parsed.command, parsed.loop, parsed.dryRun);
         if (parsed.command === "doctor")
             return await doctor(parsed.root);
+        if (parsed.command === "tui")
+            return { exitCode: 0, stdout: JSON.stringify(await removeTuiPlugin(parsed.root, parsed.dryRun), null, 2) };
         if (parsed.command === "fetch-public") {
             if (!parsed.fetchPublicUrl)
                 return { exitCode: 2, stderr: "fetch-public requires a URL" };

package/dist/deliverable-hedge-guard.js

@@ -8,9 +8,9 @@ const defaultTimeoutMs = 1500;
 const maxTextBytes = 4 * 1024 * 1024;
 const maxOutputBytes = 16 * 1024 * 1024;
 const maxPendingCalls = 512;
+// Prose formats only: in config and data files (YAML, JSON, XML, CSV, TSV) a line such as `source:` is a key.
 const readerFacingExtensions = new Set([
-    ".adoc", ".csv", ".html", ".htm", ".md", ".mdx", ".org", ".rst", ".svg", ".tex", ".txt", ".tsv",
-    ".xhtml", ".xml", ".json", ".jsonc", ".yaml", ".yml"
+    ".adoc", ".html", ".htm", ".md", ".mdx", ".org", ".rst", ".svg", ".tex", ".txt", ".xhtml"
 ]);
 const officeExtensions = new Set([".docx", ".pptx", ".pdf"]);
 const packageSkillRoot = fileURLToPath(new URL("../skills/lit-humanizer", import.meta.url));

package/dist/tui/mission-band.d.ts

@@ -0,0 +1,47 @@
+import { type MotionFrame } from "./mission-motion.ts";
+import { type MissionView } from "./mission-model.ts";
+import type { ChipShimmer, SkillChip } from "./mission-skills.ts";
+import { type LastMission, type Line, type MissionPalette } from "./mission-text.ts";
+export type BandOptions = {
+    readonly enabled: boolean;
+    readonly card: boolean;
+};
+/**
+ * Reads the band switches from the plugin's tui.json options: `band: false` turns the band off,
+ * `band: { card: true }` adds the detail card under the status card. Anything else keeps the defaults.
+ */
+export declare function readBandOptions(options: unknown): BandOptions;
+/**
+ * The skill chips row, exactly `width` cells: bright accent pills for the current request first, then
+ * dim recent names, and `+N` for the ones that do not fit. The label goes before any chip does.
+ */
+export declare function skillRow(chips: readonly SkillChip[], shimmer: ChipShimmer | undefined, palette: MissionPalette, width: number): Line;
+export type CardFigures = {
+    readonly contextPercent: number | null;
+    readonly branch?: string;
+    readonly inLane: boolean;
+};
+export type CardInputs = {
+    readonly view: MissionView;
+    readonly frame: MotionFrame;
+    readonly chips: readonly SkillChip[];
+    readonly shimmer?: ChipShimmer;
+    readonly figures: CardFigures;
+    /** The project's last goal, shown on the track while the session has no lit mission. */
+    readonly last?: LastMission;
+};
+/**
+ * The status card: four rows of exactly `width` cells whether the session is idle or working, so
+ * the prompt never moves. Each row sheds its own low-priority parts as the terminal narrows.
+ */
+export declare function statusCard(input: CardInputs, palette: MissionPalette, width: number): Line[];
+export type BandCard = {
+    readonly title: string;
+    readonly border: string;
+    readonly rows: readonly Line[];
+};
+/**
+ * The opt-in detail card under the status card. It keeps a fixed four rows whenever a goal exists, warnings
+ * first, so turning a warning on or off never moves the prompt.
+ */
+export declare function bandCard(view: MissionView, frame: MotionFrame, palette: MissionPalette, width: number): BandCard | undefined;