@litfamily/litopencode 1.0.0

package/dist/cli/types.d.ts

@@ -0,0 +1,188 @@
+import type { OpenCodeHostCapabilities } from "./host-capabilities.ts";
+export type CliResult = {
+    readonly exitCode: number;
+    readonly stdout?: string;
+    readonly stderr?: string;
+};
+export type PackageMetadata = {
+    readonly name: string;
+    readonly version: string;
+    readonly packageRoot: string;
+};
+export type ParsedArgs = {
+    readonly command?: string;
+    readonly root: string;
+    readonly fetchPublicUrl?: string;
+    readonly fetchPublicJson: boolean;
+    readonly fetchPublicAllowPrivateNetwork: boolean;
+    readonly fetchPublicTimeoutMs?: number;
+    readonly fetchPublicMaxBytes?: number;
+    readonly dryRun: boolean;
+    readonly permissionMode: InstallPermissionMode;
+    readonly permissionModeExplicit: boolean;
+    readonly permissionPrompt: PermissionPromptMode;
+    readonly modelSelection?: InstallModelSelection;
+    readonly modelPrompt: ModelPromptMode;
+    readonly outputStylePrompt: PermissionPromptMode;
+    readonly loop: LoopArgs;
+};
+export type LoopArgs = {
+    readonly projectRoot: string;
+    readonly json: boolean;
+    readonly force: boolean;
+    readonly needsUserDecision: boolean;
+    readonly sessionId?: string;
+    readonly objective?: string;
+    readonly title?: string;
+    readonly criteria: readonly string[];
+    readonly criterionId?: string;
+    readonly kind?: string;
+    readonly ref?: string;
+    readonly detail?: string;
+    readonly status?: string;
+    readonly summary?: string;
+    readonly directive?: string;
+    readonly resolve?: string;
+    readonly signal?: string;
+    readonly skillId?: string;
+    readonly observed?: string;
+    readonly proposal?: string;
+};
+export type InstallModelRoute = {
+    readonly provider: string;
+    readonly model: string;
+    readonly effort?: InstallModelEffort;
+};
+export type InstallModelSelection = InstallModelRoute & {
+    readonly helper?: InstallModelRoute;
+};
+export type InstallModelEffort = "low" | "medium" | "high" | "xhigh" | "max";
+export type ModelConfigClass = "fresh" | "managed_legacy" | "gpt56_managed" | "astra_managed" | "gpt56_other" | "custom" | "mixed";
+export type ModelConfigClassification = {
+    readonly class: ModelConfigClass;
+    readonly originalDispatchId: string | null;
+};
+export type ModelPromptMode = "auto" | "always" | "never";
+export type PermissionPromptMode = "auto" | "always" | "never";
+export type InstallPermissionMode = "safe" | "balanced" | "yolo";
+export type InstallPermissionChoice = {
+    readonly mode: InstallPermissionMode;
+    readonly explicit: boolean;
+};
+export type InstallProgress = {
+    start(packageLabel: string): Promise<void>;
+    run<T>(label: InstallStageLabel, task: () => Promise<T>): Promise<T>;
+    complete(): Promise<void>;
+    fail(message: string): Promise<void>;
+};
+export type InstallStageLabel = "Resolve package" | "Read OpenCode config" | "Write litopencode.json" | "Register plugin" | "Verify install";
+export type JsonPatchOperation = {
+    readonly op: "add";
+    readonly path: "/plugin";
+    readonly value: readonly string[];
+} | {
+    readonly op: "replace";
+    readonly path: "/plugin";
+    readonly value: readonly string[];
+} | {
+    readonly op: "replace";
+    readonly path: "/plugin";
+    readonly value: readonly unknown[];
+} | {
+    readonly op: "add";
+    readonly path: "/plugin/-";
+    readonly value: string;
+} | {
+    readonly op: "replace";
+    readonly path: `/plugin/${number}`;
+    readonly value: unknown;
+};
+export type PluginMutation = {
+    readonly changed: boolean;
+    readonly plugin: {
+        readonly alreadyPresent: boolean;
+        readonly currentCount: number;
+        readonly resultCount: number;
+        readonly add: readonly string[];
+    };
+    readonly patch: readonly JsonPatchOperation[];
+};
+export type InstallRouteReport = {
+    readonly managed: Readonly<Record<string, {
+        readonly agentId: string;
+        readonly model?: string;
+        readonly variant?: string;
+        readonly reasoningEffort?: string;
+        readonly status: "configured";
+    }>>;
+    readonly preservedAgents: readonly string[];
+    readonly planningOnly: {
+        readonly agentId: "lit-plan";
+        readonly permissions: {
+            readonly edit: "deny";
+            readonly bash: "deny";
+            readonly task: "deny";
+        };
+        readonly tools: {
+            readonly write: false;
+            readonly edit: false;
+            readonly bash: false;
+            readonly task: false;
+        };
+    };
+};
+export type InstallReport = {
+    readonly dryRun: boolean;
+    readonly path: string;
+    readonly litopencodeConfig: {
+        readonly path: string;
+        readonly alreadyPresent: boolean;
+        readonly changed: boolean;
+        readonly agents: readonly string[];
+        readonly categories: readonly string[];
+        readonly model: {
+            readonly provider?: string;
+            readonly model?: string;
+            readonly effort?: InstallModelEffort;
+            readonly helper?: InstallModelRoute;
+            readonly classification: ModelConfigClassification;
+            readonly existingVariant?: string;
+            readonly changed: boolean;
+        };
+        readonly permissionMode: {
+            readonly mode: InstallPermissionMode;
+            readonly changed: boolean;
+        };
+        readonly outputStyle: {
+            readonly style: string;
+            readonly changed: boolean;
+        };
+    };
+    readonly plugin: PluginMutation["plugin"];
+    readonly commandAliases: {
+        readonly path: string;
+        readonly changed: boolean;
+        readonly write: readonly string[];
+        readonly preserve: readonly string[];
+    };
+    readonly nativeSkills: {
+        readonly path: string;
+        readonly changed: boolean;
+        readonly write: readonly string[];
+        readonly preserve: readonly string[];
+        readonly collisions: readonly string[];
+    };
+    readonly hostLimits: {
+        readonly path: string;
+        readonly reconfigure: boolean;
+        readonly changed: boolean;
+        readonly contextCeilingTokens: number;
+        readonly compactionTriggerTokens: number;
+        readonly compactionReserveTokens: number;
+    };
+    readonly patch: readonly JsonPatchOperation[];
+    readonly changed: boolean;
+    readonly routes?: InstallRouteReport;
+    readonly capabilities: OpenCodeHostCapabilities;
+    readonly package: Pick<PackageMetadata, "name" | "version">;
+};

package/dist/cli/types.js

@@ -0,0 +1 @@
+export {};

package/dist/cli/update-check.d.ts

@@ -0,0 +1,2 @@
+export declare function runUpdateCheckHelper(argv: readonly string[], refresh?: () => Promise<void>): Promise<void>;
+export declare function main(argv?: readonly string[]): Promise<void>;

package/dist/cli/update-check.js

@@ -0,0 +1,15 @@
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { refreshUpdateCache } from "./update-notifier.js";
+export async function runUpdateCheckHelper(argv, refresh = refreshUpdateCache) {
+    if (argv.length !== 1 || argv[0] !== "--refresh")
+        return;
+    await refresh();
+}
+export async function main(argv = process.argv.slice(2)) {
+    await runUpdateCheckHelper(argv);
+}
+const invokedPath = process.argv[1] ? path.resolve(process.argv[1]) : undefined;
+if (invokedPath === fileURLToPath(import.meta.url)) {
+    void main().catch(() => undefined);
+}

package/dist/cli/update-notifier.d.ts

@@ -0,0 +1,70 @@
+import type { IncomingMessage, RequestOptions } from "node:http";
+export declare const npmLatestUrl = "https://registry.npmjs.org/%40litfamily%2Flitopencode/latest";
+export declare const updateTimeoutMs = 3000;
+export declare const updateResponseMaxBytes: number;
+export declare const updateCheckIntervalMs: number;
+export declare const updateLockStaleMs: number;
+export type UpdateCache = {
+    readonly schemaVersion: 1;
+    readonly packageName: "@litfamily/litopencode";
+    readonly latestVersion?: string;
+    readonly checkedAt?: number;
+    readonly failedAt?: number;
+    readonly attemptedAt?: number;
+    readonly ownerGeneration?: string;
+};
+type UpdateNotifierGate = {
+    readonly argv: readonly string[];
+    readonly exitCode: number;
+    readonly env: NodeJS.ProcessEnv;
+    readonly stdinIsTTY: boolean | undefined;
+    readonly stdoutIsTTY: boolean | undefined;
+    readonly stderrIsTTY: boolean | undefined;
+};
+type RunUpdateNotifierOptions = UpdateNotifierGate & {
+    readonly homeDir?: string;
+    readonly currentVersion?: string;
+    readonly now?: number;
+    readonly writeStderr?: (text: string) => void;
+    readonly launchRefresh?: () => void;
+};
+type RefreshUpdateCacheOptions = {
+    readonly homeDir?: string;
+    readonly now?: number;
+    readonly clock?: () => number;
+    readonly fetchLatestVersion?: () => Promise<string>;
+};
+type RegistryResponse = Pick<IncomingMessage, "statusCode" | "headers"> & AsyncIterable<Uint8Array | string>;
+type RegistryRequest = {
+    destroy(error?: Error): void;
+    once(event: "error", listener: (error: Error) => void): unknown;
+};
+type RegistryTransport = (url: string, options: RequestOptions, callback: (response: RegistryResponse) => void) => RegistryRequest;
+type DetachedUpdateChild = {
+    once(event: "error", listener: (error: Error) => void): unknown;
+    unref(): void;
+};
+type DetachedUpdateSpawn = (command: string, args: string[], options: {
+    readonly detached: true;
+    readonly stdio: "ignore";
+    readonly env: NodeJS.ProcessEnv;
+}) => DetachedUpdateChild;
+export declare function parseStableVersion(value: unknown): readonly [bigint, bigint, bigint] | undefined;
+export declare function compareStableVersions(left: unknown, right: unknown): -1 | 0 | 1 | undefined;
+export declare function updateCachePath(homeDir?: string): string;
+export declare function updateLockPath(homeDir?: string): string;
+export declare function updateTransitionLockPath(homeDir?: string): string;
+export declare function parseUpdateCache(value: unknown): UpdateCache | undefined;
+export declare function readUpdateCache(cachePath: string): Promise<UpdateCache | undefined>;
+export declare function writeUpdateCacheAtomically(cachePath: string, cache: UpdateCache): Promise<void>;
+export declare function shouldRunUpdateNotifier(input: UpdateNotifierGate): boolean;
+export declare function shouldRefreshUpdateCache(cache: UpdateCache | undefined, now: number): boolean;
+export declare function renderUpdateNotice(currentVersion: unknown, latestVersion: unknown): string | undefined;
+export declare function readRegistryLatestVersion(response: RegistryResponse): Promise<string>;
+export declare function requestRegistryLatestVersionWithTransport(transport: RegistryTransport): Promise<string>;
+export declare function requestRegistryLatestVersion(): Promise<string>;
+export declare function refreshUpdateCache(options?: RefreshUpdateCacheOptions): Promise<void>;
+export declare function launchDetachedUpdateRefreshWith(spawnProcess: DetachedUpdateSpawn, env: NodeJS.ProcessEnv, execPath: string, helperPath: string): void;
+export declare function launchDetachedUpdateRefresh(env?: NodeJS.ProcessEnv): void;
+export declare function runUpdateNotifier(options: RunUpdateNotifierOptions): Promise<void>;
+export {};