loadout-ai 0.6.0 → 0.8.0

package/dist/src/core/completion.js

@@ -1,143 +0,0 @@
-const commands = [
-    "guide",
-    "advanced",
-    "setup",
-    "upgrade",
-    "init",
-    "lock",
-    "export",
-    "import",
-    "audit",
-    "create",
-    "pack",
-    "publish",
-    "search",
-    "add",
-    "unadd",
-    "list",
-    "scan",
-    "reconcile",
-    "status",
-    "versions",
-    "skill-audit",
-    "doctor",
-    "health",
-    "compare",
-    "optimize",
-    "activate",
-    "enable",
-    "disable",
-    "adopt",
-    "library",
-    "update",
-    "rollback",
-    "discover",
-    "candidate",
-    "review-queue",
-    "review",
-    "alerts",
-    "alert-ignore",
-    "alert-pin",
-    "alert-unpin",
-    "alert-pins",
-    "mcp",
-    "mcp-recipe",
-    "mcp-config",
-    "models",
-    "credentials",
-    "schedule",
-    "unschedule",
-    "autopilot",
-    "tool",
-    "report",
-    "share",
-    "card",
-    "compare-loadouts",
-    "badge",
-    "inspect",
-    "evaluate",
-    "watch",
-    "sandbox-run",
-    "codex-mcp-config",
-    "plan",
-    "install",
-    "convert",
-    "canary",
-    "capabilities",
-    "catalog",
-    "profiles",
-    "recommend",
-    "improve",
-    "improve-feedback",
-    "sync",
-    "outcome",
-    "outcomes",
-    "remove",
-    "uninstall",
-    "serve",
-    "completion",
-];
-const modelCommands = ["status", "set", "verify"];
-const credentialCommands = ["status", "set", "check", "delete"];
-const candidateCommands = ["list", "inspect", "propose"];
-export function renderShellCompletion(shell) {
-    const words = commands.join(" ");
-    switch (shell) {
-        case "bash":
-            return `# Loadout command completion
-_loadout() {
-  local current="\${COMP_WORDS[COMP_CWORD]}"
-  local commands="${words}"
-  if [[ COMP_CWORD -eq 1 ]]; then
-    COMPREPLY=( $(compgen -W "$commands" -- "$current") )
-  elif [[ COMP_CWORD -eq 2 && "\${COMP_WORDS[1]}" == "models" ]]; then
-    COMPREPLY=( $(compgen -W "${modelCommands.join(" ")}" -- "$current") )
-  elif [[ COMP_CWORD -eq 2 && "\${COMP_WORDS[1]}" == "credentials" ]]; then
-    COMPREPLY=( $(compgen -W "${credentialCommands.join(" ")}" -- "$current") )
-  elif [[ COMP_CWORD -eq 2 && "\${COMP_WORDS[1]}" == "candidate" ]]; then
-    COMPREPLY=( $(compgen -W "${candidateCommands.join(" ")}" -- "$current") )
-  fi
-}
-complete -F _loadout loadout
-`;
-        case "zsh":
-            return `#compdef loadout
-typeset -a commands model_commands credential_commands candidate_commands
-commands=(${commands.map((command) => `'${command}'`).join(" ")})
-model_commands=(${modelCommands.map((command) => `'${command}'`).join(" ")})
-credential_commands=(${credentialCommands.map((command) => `'${command}'`).join(" ")})
-candidate_commands=(${candidateCommands.map((command) => `'${command}'`).join(" ")})
-if (( CURRENT == 2 )); then
-  _describe 'command' commands
-elif (( CURRENT == 3 )) && [[ $words[2] == models ]]; then
-  _describe 'models command' model_commands
-elif (( CURRENT == 3 )) && [[ $words[2] == credentials ]]; then
-  _describe 'credentials command' credential_commands
-elif (( CURRENT == 3 )) && [[ $words[2] == candidate ]]; then
-  _describe 'candidate command' candidate_commands
-fi
-`;
-        case "fish":
-            return [
-                ...commands.map((command) => `complete -c loadout -f -n '__fish_use_subcommand' -a ${command}`),
-                ...modelCommands.map((command) => `complete -c loadout -f -n '__fish_seen_subcommand_from models' -a ${command}`),
-                ...credentialCommands.map((command) => `complete -c loadout -f -n '__fish_seen_subcommand_from credentials' -a ${command}`),
-                ...candidateCommands.map((command) => `complete -c loadout -f -n '__fish_seen_subcommand_from candidate' -a ${command}`),
-            ]
-                .join("\n")
-                .concat("\n");
-        case "powershell":
-            return `Register-ArgumentCompleter -Native -CommandName loadout -ScriptBlock {
-  param($wordToComplete, $commandAst, $cursorPosition)
-  $elements = @($commandAst.CommandElements | ForEach-Object { $_.Extent.Text })
-  $candidates = if ($elements.Count -ge 2 -and $elements[1] -eq 'models') { @(${modelCommands.map((command) => `'${command}'`).join(", ")}) } elseif ($elements.Count -ge 2 -and $elements[1] -eq 'credentials') { @(${credentialCommands.map((command) => `'${command}'`).join(", ")}) } elseif ($elements.Count -ge 2 -and $elements[1] -eq 'candidate') { @(${candidateCommands.map((command) => `'${command}'`).join(", ")}) } else { @(${commands.map((command) => `'${command}'`).join(", ")}) }
-  $candidates | Where-Object { $_ -like "$wordToComplete*" } | ForEach-Object { [System.Management.Automation.CompletionResult]::new($_, $_, 'ParameterValue', $_) }
-}
-`;
-    }
-}
-export function parseCompletionShell(value) {
-    if (["bash", "zsh", "fish", "powershell"].includes(value))
-        return value;
-    throw new Error("Supported shells: bash, zsh, fish, powershell");
-}

package/dist/src/core/handoff.js

@@ -1,161 +0,0 @@
-import { readFile, writeFile, mkdir } from "node:fs/promises";
-import { join } from "node:path";
-import { randomUUID } from "node:crypto";
-import { writeFileAtomically } from "./atomic-file.js";
-const HANDOFF_DIR = ".handoff";
-const MESSAGES_FILE = "messages.jsonl";
-const PROTOCOL_FILE = "PROTOCOL.md";
-function handoffDir(projectRoot) {
-    return join(projectRoot, HANDOFF_DIR);
-}
-function messagesPath(projectRoot) {
-    return join(handoffDir(projectRoot), MESSAGES_FILE);
-}
-export async function isHandoffInitialized(projectRoot) {
-    try {
-        await readFile(join(handoffDir(projectRoot), PROTOCOL_FILE), "utf8");
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-export async function initHandoff(projectRoot) {
-    const dir = handoffDir(projectRoot);
-    await mkdir(dir, { recursive: true });
-    const protocol = [
-        "# Handoff Protocol",
-        "",
-        "This directory enables asynchronous task handoff between AI coding agents.",
-        "Generated by `loadout handoff init`. Compatible with the JSONL handoff convention.",
-        "",
-        "## Message types",
-        "",
-        "- **task**: assign work to another agent",
-        "- **handoff**: transfer in-progress work with context",
-        "- **question**: ask another agent for input",
-        "- **done**: signal completion",
-        "- **status**: progress update",
-        "- **error**: report a failure",
-        "- **cancel**: withdraw a task",
-        "",
-        "## Files",
-        "",
-        "- `messages.jsonl` — append-only message log (one JSON object per line)",
-        "- `PROTOCOL.md` — this file",
-        "",
-        "## Usage",
-        "",
-        "```",
-        "loadout handoff send codex 'write unit tests for auth module'",
-        "loadout handoff send claude-code 'review the API changes' --context 'see PR #42'",
-        "loadout handoff status",
-        "loadout handoff done <message-id>",
-        "```",
-        "",
-        "Agents read this directory on wake. Loadout manages the message log;",
-        "each agent's own CLAUDE.md / AGENTS.md can reference .handoff/ for pickup.",
-        "",
-    ].join("\n");
-    await writeFileAtomically(join(dir, PROTOCOL_FILE), protocol);
-    // Create empty messages file if it doesn't exist
-    try {
-        await readFile(messagesPath(projectRoot));
-    }
-    catch {
-        await writeFile(messagesPath(projectRoot), "", "utf8");
-    }
-    return dir;
-}
-export async function sendHandoff(projectRoot, to, description, options = {}) {
-    if (!(await isHandoffInitialized(projectRoot))) {
-        throw new Error("Handoff not initialized. Run `loadout handoff init` first.");
-    }
-    const message = {
-        id: randomUUID().slice(0, 8),
-        type: options.type ?? "task",
-        from: options.from ?? "user",
-        to,
-        description,
-        ...(options.context ? { context: options.context } : {}),
-        timestamp: new Date().toISOString(),
-    };
-    const path = messagesPath(projectRoot);
-    const line = JSON.stringify(message) + "\n";
-    await writeFile(path, line, { flag: "a" });
-    return message;
-}
-export async function markDone(projectRoot, messageId) {
-    const messages = await readMessages(projectRoot);
-    const original = messages.find((m) => m.id === messageId);
-    if (!original)
-        throw new Error(`Message '${messageId}' not found`);
-    if (original.type === "done")
-        throw new Error(`Message '${messageId}' is already done`);
-    return sendHandoff(projectRoot, original.from, `Completed: ${original.description}`, {
-        from: original.to,
-        type: "done",
-        context: `Resolves ${messageId}`,
-    });
-}
-export async function readMessages(projectRoot) {
-    if (!(await isHandoffInitialized(projectRoot)))
-        return [];
-    try {
-        const content = await readFile(messagesPath(projectRoot), "utf8");
-        return content
-            .split("\n")
-            .filter(Boolean)
-            .map((line) => JSON.parse(line));
-    }
-    catch {
-        return [];
-    }
-}
-export async function getHandoffState(projectRoot) {
-    const initialized = await isHandoffInitialized(projectRoot);
-    const messages = initialized ? await readMessages(projectRoot) : [];
-    const doneIds = new Set(messages
-        .filter((m) => m.type === "done")
-        .flatMap((m) => {
-        const match = m.context?.match(/Resolves (\w+)/);
-        return match ? [match[1]] : [];
-    }));
-    const pending = messages.filter((m) => m.type === "task" && !doneIds.has(m.id));
-    const done = messages.filter((m) => m.type === "task" && doneIds.has(m.id));
-    return {
-        initialized,
-        directory: handoffDir(projectRoot),
-        messages,
-        pending,
-        done,
-    };
-}
-export function formatHandoffStatus(state) {
-    if (!state.initialized)
-        return "Handoff not initialized. Run `loadout handoff init`.";
-    if (state.messages.length === 0)
-        return "No handoff messages yet. Send one with `loadout handoff send <agent> <task>`.";
-    const lines = [];
-    if (state.pending.length) {
-        lines.push(`Pending (${state.pending.length}):`);
-        for (const m of state.pending) {
-            lines.push(`  ${m.id}  ${m.from} → ${m.to}  ${m.description}`);
-        }
-    }
-    if (state.done.length) {
-        if (lines.length)
-            lines.push("");
-        lines.push(`Done (${state.done.length}):`);
-        for (const m of state.done) {
-            lines.push(`  ${m.id}  ${m.from} → ${m.to}  ${m.description}`);
-        }
-    }
-    const other = state.messages.filter((m) => m.type !== "task" && m.type !== "done");
-    if (other.length) {
-        if (lines.length)
-            lines.push("");
-        lines.push(`Other messages: ${other.length}`);
-    }
-    return lines.join("\n");
-}

package/docs/ACTIVE_SET.md

@@ -1,53 +0,0 @@
-# Reviewed library and active-set contract
-
-Loadout separates four facts that package managers often collapse into one word:
-
-- **cache**: `missing` or `downloaded` says whether Loadout has a private byte-for-byte
-  library copy;
-- **review**: `unreviewed`, `reviewed`, or `quarantined` records evidence policy and
-  never follows popularity alone;
-- **installation**: `installed` or `removed` records whether Loadout still manages the
-  package; and
-- **activation**: `active` or `disabled` is per skill unit and per agent, because one
-  skill from a collection can be visible to Claude Code while another stays disabled
-  for Codex.
-
-Maximum Library starts reviewed skill units as `downloaded + reviewed + installed +
-disabled`. It can therefore hold hundreds of candidates without exposing hundreds of
-instructions to an agent. Power is an intentionally broader active profile; Stable is
-the smallest active foundation.
-
-An initial install is active and may have `cache:missing`. On the first disable,
-Loadout verifies that every managed file is unchanged and that no untracked file would
-be removed, copies the complete skill directories into its private library, verifies
-their hashes, and only then removes the agent-visible copies. This is the explicit
-migration boundary for older installations.
-
-`enable` verifies the private library hashes and refuses to overwrite any occupied
-agent target. It restores the exact cached bytes but keeps the library copy. Both
-commands are dry-run by default, can change several packages and agents under one
-snapshot, write a durable transaction journal before mutation, and can be reversed by
-`loadout rollback --snapshot <id>`.
-
-Only Loadout-managed skill directories participate. Existing unmanaged content is
-never silently adopted, moved, or deleted. MCP entries and other executable/configured
-components are deliberately outside active-set toggling; they retain their existing
-explicit configuration and removal workflows.
-
-A disabled package must be enabled before its tracked source can be updated. This
-prevents the update workflow from silently recreating agent-visible files and makes the
-activation transition explicit.
-
-## Commands
-
-```bash
-loadout library
-loadout disable <package-or-package/skill> [more-selectors] [--agents codex,claude-code]
-loadout disable <package-or-package/skill> --yes
-loadout enable <package-or-package/skill> --yes
-loadout activate --project . --limit 30
-loadout optimize --project .
-loadout rollback --snapshot <id>
-```
-
-Machine-readable planning and results are available with `--json`.

package/docs/COMPATIBILITY_POLICY.md

@@ -1,22 +0,0 @@
-# Compatibility policy
-
-Loadout uses the same adapter matrix in inspection and installation. Each
-agent/component cell is one of:
-
-- **native** — Loadout writes the documented component format to the
-  agent-owned location.
-- **adapted** — Loadout has a reviewed, tested mapping to an agent-specific
-  layout or explicit config writer. The plan warns about the adaptation.
-- **unsupported** — Loadout does not infer a location, convert the component,
-  or write anything.
-
-All supported platforms (Windows, macOS, and Linux) use this policy. WSL is
-Linux-side only: Loadout manages the POSIX home directory and never silently
-rewrites a Windows profile. Agent adapters are deliberately conservative:
-skills are native wherever a documented skill directory exists; commands,
-rules, and agents are native only where the adapter supplies a concrete
-directory; MCP is config-scoped and adapted only through its explicit JSON or
-Codex TOML planner; and plugin manifests are inspected/normalized but their
-runtime hooks are never converted or executed.
-
-Use `loadout capabilities --inspect` to view the matrix and local inventory.

package/docs/CONVERSION_AND_SANDBOX.md

@@ -1,27 +0,0 @@
-# Conversion loss reports and installer sandbox boundary
-
-## Cross-agent conversion
-
-The only safe initial conversion target is a static instruction file. A source skill
-can be copied to an agent's documented native skill directory when that adapter marks
-skills `native`. For a target that supports only commands, Loadout may create one
-explicit command wrapper pointing at the same static instructions.
-
-Every conversion emits a loss report containing source component, target component,
-preserved fields, dropped fields, and the reason. Hooks, subagents, lifecycle scripts,
-dynamic variables, permissions, and MCP servers are never silently converted. A loss
-report with dropped executable behavior requires user approval and defaults to no
-write.
-
-## Third-party installer threat model
-
-An installer can read secrets, write outside its target, alter shell startup files,
-open network connections, launch processes, or exploit the host. Therefore source
-repository scripts are never run on the host. Static package parsing is the normal
-path.
-
-If a future disposable sandbox runner is enabled, it must use a fresh filesystem,
-read-only source mount, no host home mount, no inherited environment variables, no
-Docker socket, restricted network disabled by default, bounded CPU/memory/time, and
-an exported file manifest. Its output is an untrusted proposal that still goes through
-the normal plan/safety/approval path. Failure or timeout discards the sandbox.