@aron98/load-lock 1.5.0 → 1.6.0

package/dist/cli/setup.d.ts

@@ -0,0 +1,131 @@
+import { type InstalledCopy } from "./copies.js";
+import { type RuntimeCopy } from "../shared/runtimes.js";
+/**
+ * Name of the Claude Code plugin (decided on #61: the plugin is not called
+ * `load-lock`, so it never collides with the standalone skill). Matched as
+ * `<name>@<marketplace>` in `enabledPlugins`, whatever the marketplace.
+ */
+export declare const CLAUDE_PLUGIN_NAME = "load-lock-plugin";
+export declare const HARNESSES: readonly ["claude-code", "opencode", "codex", "cursor", "gemini-cli", "copilot-cli", "cline", "roo-code", "goose", "omac"];
+export type Harness = (typeof HARNESSES)[number];
+export type IntegrationKind = "plugin" | "hooks" | "mcp" | "policy" | "skill" | "grants";
+/**
+ * Who wrote the entry: `installer` = `load-lock install` (exact shape it
+ * writes), `harness` = the harness's own plugin state (e.g. Claude Code
+ * `enabledPlugins`), `ace` = an ACE install (`.ace.json` stamp next to it),
+ * `other` = anything else (manual edits, npx entries, foreign tools).
+ */
+export type Owner = "installer" | "harness" | "ace" | "other";
+export interface Integration {
+    kind: IntegrationKind;
+    scope: "user" | "project";
+    /** File (or directory) the entry lives in. */
+    file: string;
+    /** Short description of the entry (key, events, ...). */
+    detail: string;
+    owner: Owner;
+    /** Package root of the load-lock copy the entry runs, when it names one. */
+    copy?: string;
+    /** True when that copy no longer exists on disk. */
+    stale?: boolean;
+    /** Plugins only: the harness's enabled flag. */
+    enabled?: boolean;
+}
+/**
+ * Rung on the ladder (#47): `plugin` = harness plugin active, `loose` =
+ * `load-lock install` wiring (hooks / policy / grants), `mcp` = only an MCP
+ * registration, `skill` = only the skill, `none` = nothing found.
+ */
+export type Rung = "plugin" | "loose" | "mcp" | "skill" | "none";
+export interface HarnessInventory {
+    harness: Harness;
+    rung: Rung;
+    integrations: Integration[];
+    /** Duplicates, stale entries and other problems worth fixing. */
+    findings: string[];
+}
+export interface Inventory {
+    home: string;
+    project: string;
+    harnesses: HarnessInventory[];
+    runtime: {
+        /** Copies detectable on disk (copies.ts). */
+        copies: InstalledCopy[];
+        /** The copy the daemon last recorded in daemon.json (#52). */
+        daemon: {
+            path: string;
+            version: string | null;
+        } | null;
+        /** Copies the daemon has seen via the client handshake (#52). */
+        known: RuntimeCopy[];
+    };
+    findings: string[];
+}
+export interface InventoryOptions {
+    project: string;
+    home?: string;
+    env?: NodeJS.ProcessEnv;
+    platform?: NodeJS.Platform;
+}
+/**
+ * Who owns a skill directory: `ace` when ACE stamped it (`.ace.json`),
+ * `installer` when it is the dir `load-lock install` writes (a real
+ * directory, not a symlink to someone's checkout), else `other`.
+ * `install` / `uninstall` only write or remove an `installer` dir (#89).
+ */
+export declare function skillDirOwner(dir: string, installerDir?: string): Owner;
+/** A plugin entry the harness will actually load (ACE skills-dir plugins are unverified, #63). */
+export declare function activePlugin(i: Integration): boolean;
+/** Inventory of one harness only (no runtime copies). */
+export declare function inventoryHarness(h: Harness, opts: InventoryOptions): HarnessInventory;
+/**
+ * Claude Code's mode (#62): `plugin` (the plugin is active), `loose`
+ * (`load-lock install` wiring: MCP server, hooks or CLAUDE.md section),
+ * `both`, or `none`. The skill doesn't count: the plugin ships none.
+ */
+export type ClaudeCodeMode = "plugin" | "loose" | "both" | "none";
+export declare function claudeCodeMode(h: HarnessInventory): ClaudeCodeMode;
+export declare function inventory(opts: InventoryOptions): Inventory;
+/** Human-readable inventory. */
+export declare function formatInventory(inv: Inventory): string;
+export interface PlanStep {
+    harness: Harness;
+    /**
+     * `install`: run `load-lock install --harness <h>` (after removing
+     * installer-shaped hooks of other/missing copies, and a stale codex MCP
+     * block, which `install` alone would keep). `remove-loose`: drop the
+     * loose Claude Code wiring an active plugin replaces (MCP server, hooks,
+     * CLAUDE.md section; the skill stays). `manual`: printed, never applied.
+     */
+    action: "install" | "remove-loose" | "manual";
+    detail: string;
+}
+export interface Plan {
+    steps: PlanStep[];
+    /** One-time hints (upgrade path), not actions. */
+    hints: string[];
+}
+export interface PlanOptions {
+    /** Package root of the copy running setup; null when unknown. */
+    selfCopy: string | null;
+    /** True when that copy lives in a cache npm/opencode may prune. */
+    selfEphemeral: boolean;
+}
+/** The running copy, and whether it sits in the npx / opencode cache. */
+export declare function selfCopy(platform?: NodeJS.Platform, env?: NodeJS.ProcessEnv): PlanOptions;
+export declare function planConverge(inv: Inventory, opts: PlanOptions): Plan;
+/**
+ * Drop the loose Claude Code wiring (installer-shaped entries only); keep
+ * the skill. Shared by `setup --yes` (`remove-loose`) and `install` when
+ * the plugin is enabled (#62).
+ */
+export declare function removeClaudeLoose(h: HarnessInventory): string[];
+export interface ApplyOptions {
+    project: string;
+    /** dist/ of the running copy (what `install` is called with). */
+    binDir?: string;
+}
+/** Apply the non-manual steps in order; returns what was done. */
+export declare function applyPlan(inv: Inventory, plan: Plan, opts: ApplyOptions): Promise<string[]>;
+/** Human-readable plan. */
+export declare function formatPlan(plan: Plan, applied?: string[]): string;