@yagni-app/code-staging 0.1.0-staging.1009.1 → 0.1.0-staging.1015.1

package/dist/claudeCompat.d.ts

@@ -9,6 +9,14 @@
  * `--prompt-template` flags, so nothing repo-local is ever written and no
  * per-profile settings file accumulates stale per-repo paths.
  *
+ * The same seams carry installed/enabled Claude Code plugins and the repo's
+ * own `.claude-plugin/marketplace.json` plugins (see claudePlugins.ts):
+ * plugin skills → `--skill`, plugin commands → `--prompt-template`, plugin
+ * `agents/` dirs → YAGNI_CLAUDE_AGENT_DIRS for the extension's subagent
+ * discovery. `.claude/rules` dirs travel as YAGNI_CLAUDE_RULES_DIRS for the
+ * extension's system-prompt rules injection. Design + on-disk evidence:
+ * docs/superpowers/specs/2026-08-08-claude-plugins-design.md.
+ *
  * Trust: pi gates project-local resources behind a per-folder trust decision
  * stored in `<agentDir>/trust.json`. Explicit CLI paths bypass that gate, so
  * the launcher enforces the SAME decision itself: project `.claude` dirs are
@@ -20,14 +28,24 @@
  *
  * Set YAGNI_DISABLE_CLAUDE_COMPAT=1 to turn the whole bridge off.
  */
+import { type PluginAssets } from "./claudePlugins.js";
 export declare const CLAUDE_COMPAT_DISABLE_ENV = "YAGNI_DISABLE_CLAUDE_COMPAT";
+/** Plugin `agents/` dirs for the extension's subagent discovery (delimiter-joined). */
+export declare const CLAUDE_AGENT_DIRS_ENV = "YAGNI_CLAUDE_AGENT_DIRS";
+/** `.claude/rules` dirs for the extension's rules injection (delimiter-joined). */
+export declare const CLAUDE_RULES_DIRS_ENV = "YAGNI_CLAUDE_RULES_DIRS";
 export interface ClaudeAssetDirs {
     skills: string | null;
     commands: string | null;
+    rules: string | null;
 }
 export interface ClaudeCompatProbe {
     project: ClaudeAssetDirs;
     user: ClaudeAssetDirs;
+    /** Locally-present plugins sourced from repo config; trust-gated. */
+    projectPlugins: PluginAssets[];
+    /** Plugins the user enabled in their own `~/.claude`; no ceremony. */
+    userPlugins: PluginAssets[];
     /** Nearest recorded trust decision for the cwd (pi trust.json), if any. */
     projectTrust: boolean | null;
     interactive: boolean;
@@ -37,7 +55,13 @@ export interface ClaudeCompatDecision {
     userArgv: string[];
     /** Flags for project dirs; pass only once trust is established. */
     projectArgv: string[];
-    /** Ask the user for a trust decision before wiring projectArgv. */
+    /** Plugin agent dirs, split by the same trust posture. */
+    userAgentDirs: string[];
+    projectAgentDirs: string[];
+    /** `.claude/rules` dirs, user first so project rules win in the prompt. */
+    userRulesDirs: string[];
+    projectRulesDirs: string[];
+    /** Ask the user for a trust decision before wiring any project content. */
     needsPrompt: boolean;
 }
 /** Pure policy: what to wire, and whether a trust prompt is required first. */
@@ -67,12 +91,19 @@ export interface ClaudeCompatDeps {
     confirm?: (question: string) => Promise<boolean>;
 }
 export declare function compatDisabled(env: NodeJS.ProcessEnv): boolean;
+export interface ClaudeCompatLaunch {
+    /** Extra pi flags (`--skill` / `--prompt-template` paths). */
+    argv: string[];
+    /** Extra child env (plugin agent dirs, rules dirs) for the extension. */
+    env: Record<string, string>;
+}
 /**
- * The extra pi argv for this launch: user-scope dirs plus project dirs once
- * trusted, asking (and persisting) the trust decision when needed. Everything
- * is fail-soft — compat can only add flags, never break a launch.
+ * The extra pi argv + child env for this launch: user-scope dirs and plugins
+ * unconditionally, project-sourced dirs/plugins/rules once trusted, asking
+ * (and persisting) the trust decision when needed. Everything is fail-soft —
+ * compat can only add flags/env, never break a launch.
  */
-export declare function claudeCompatArgs(deps: ClaudeCompatDeps): Promise<string[]>;
+export declare function claudeCompatArgs(deps: ClaudeCompatDeps): Promise<ClaudeCompatLaunch>;
 /** Whether pi's trust file exists yet (used only for messaging). */
 export declare function trustFileExists(agentDir: string): boolean;
 //# sourceMappingURL=claudeCompat.d.ts.map

package/dist/claudeCompat.js

@@ -9,6 +9,14 @@
  * `--prompt-template` flags, so nothing repo-local is ever written and no
  * per-profile settings file accumulates stale per-repo paths.
  *
+ * The same seams carry installed/enabled Claude Code plugins and the repo's
+ * own `.claude-plugin/marketplace.json` plugins (see claudePlugins.ts):
+ * plugin skills → `--skill`, plugin commands → `--prompt-template`, plugin
+ * `agents/` dirs → YAGNI_CLAUDE_AGENT_DIRS for the extension's subagent
+ * discovery. `.claude/rules` dirs travel as YAGNI_CLAUDE_RULES_DIRS for the
+ * extension's system-prompt rules injection. Design + on-disk evidence:
+ * docs/superpowers/specs/2026-08-08-claude-plugins-design.md.
+ *
  * Trust: pi gates project-local resources behind a per-folder trust decision
  * stored in `<agentDir>/trust.json`. Explicit CLI paths bypass that gate, so
  * the launcher enforces the SAME decision itself: project `.claude` dirs are
@@ -22,8 +30,13 @@
  */
 import { existsSync, mkdirSync, readFileSync, realpathSync, renameSync, rmdirSync, statSync, writeFileSync } from "node:fs";
 import { homedir } from "node:os";
-import { dirname, join, resolve } from "node:path";
+import { delimiter, dirname, join, resolve } from "node:path";
+import { discoverClaudePlugins } from "./claudePlugins.js";
 export const CLAUDE_COMPAT_DISABLE_ENV = "YAGNI_DISABLE_CLAUDE_COMPAT";
+/** Plugin `agents/` dirs for the extension's subagent discovery (delimiter-joined). */
+export const CLAUDE_AGENT_DIRS_ENV = "YAGNI_CLAUDE_AGENT_DIRS";
+/** `.claude/rules` dirs for the extension's rules injection (delimiter-joined). */
+export const CLAUDE_RULES_DIRS_ENV = "YAGNI_CLAUDE_RULES_DIRS";
 function dirsToArgv(dirs) {
     const argv = [];
     if (dirs.skills)
@@ -32,13 +45,30 @@ function dirsToArgv(dirs) {
         argv.push("--prompt-template", dirs.commands);
     return argv;
 }
+function pluginsToArgv(plugins) {
+    const argv = [];
+    for (const plugin of plugins) {
+        for (const path of plugin.skillPaths)
+            argv.push("--skill", path);
+        for (const path of plugin.commandPaths)
+            argv.push("--prompt-template", path);
+    }
+    return argv;
+}
 /** Pure policy: what to wire, and whether a trust prompt is required first. */
 export function decideClaudeCompat(probe) {
-    const projectArgv = dirsToArgv(probe.project);
+    const projectArgv = [...dirsToArgv(probe.project), ...pluginsToArgv(probe.projectPlugins)];
+    const projectAgentDirs = probe.projectPlugins.flatMap((p) => p.agentDirs);
+    const projectRulesDirs = probe.project.rules ? [probe.project.rules] : [];
+    const hasProjectContent = projectArgv.length > 0 || projectAgentDirs.length > 0 || projectRulesDirs.length > 0;
     return {
-        userArgv: dirsToArgv(probe.user),
+        userArgv: [...dirsToArgv(probe.user), ...pluginsToArgv(probe.userPlugins)],
         projectArgv,
-        needsPrompt: probe.interactive && projectArgv.length > 0 && probe.projectTrust === null,
+        userAgentDirs: probe.userPlugins.flatMap((p) => p.agentDirs),
+        projectAgentDirs,
+        userRulesDirs: probe.user.rules ? [probe.user.rules] : [],
+        projectRulesDirs,
+        needsPrompt: probe.interactive && hasProjectContent && probe.projectTrust === null,
     };
 }
 function isDirectory(path) {
@@ -53,9 +83,11 @@ function isDirectory(path) {
 export function probeClaudeDirs(root) {
     const skills = join(root, ".claude", "skills");
     const commands = join(root, ".claude", "commands");
+    const rules = join(root, ".claude", "rules");
     return {
         skills: isDirectory(skills) ? skills : null,
         commands: isDirectory(commands) ? commands : null,
+        rules: isDirectory(rules) ? rules : null,
     };
 }
 // ── pi trust.json interop ───────────────────────────────────────────────────
@@ -114,7 +146,14 @@ export function readTrustDecision(agentDir, cwd) {
 export function writeTrustDecision(agentDir, cwd, decision) {
     const path = trustPath(agentDir);
     const lock = `${path}.lock`;
-    mkdirSync(agentDir, { recursive: true });
+    try {
+        mkdirSync(agentDir, { recursive: true });
+    }
+    catch {
+        // Fail-soft: an uncreatable agent dir must not discard the user's answer
+        // for this launch — the caller still applies it in-process.
+        return;
+    }
     let locked = false;
     for (let attempt = 0; attempt < 10; attempt++) {
         try {
@@ -158,38 +197,61 @@ export function compatDisabled(env) {
     return value !== undefined && value !== "" && value !== "0";
 }
 /**
- * The extra pi argv for this launch: user-scope dirs plus project dirs once
- * trusted, asking (and persisting) the trust decision when needed. Everything
- * is fail-soft — compat can only add flags, never break a launch.
+ * The extra pi argv + child env for this launch: user-scope dirs and plugins
+ * unconditionally, project-sourced dirs/plugins/rules once trusted, asking
+ * (and persisting) the trust decision when needed. Everything is fail-soft —
+ * compat can only add flags/env, never break a launch.
  */
 export async function claudeCompatArgs(deps) {
     const env = deps.env ?? process.env;
     if (compatDisabled(env))
-        return [];
+        return { argv: [], env: {} };
     const home = deps.homeDir ?? homedir();
     const projectTrust = readTrustDecision(deps.agentDir, deps.cwd);
+    let plugins;
+    try {
+        plugins = discoverClaudePlugins({ cwd: deps.cwd, homeDir: home });
+    }
+    catch {
+        plugins = { user: [], project: [] };
+    }
     const decision = decideClaudeCompat({
         project: probeClaudeDirs(deps.cwd),
         user: probeClaudeDirs(home),
+        projectPlugins: plugins.project,
+        userPlugins: plugins.user,
         projectTrust,
         interactive: deps.interactive ?? (process.stdin.isTTY === true && process.stdout.isTTY === true),
     });
-    const argv = [...decision.userArgv];
-    if (decision.projectArgv.length > 0) {
-        let trusted = projectTrust;
-        if (decision.needsPrompt && deps.confirm) {
-            try {
-                trusted = await deps.confirm("This folder has Claude Code assets (.claude/skills, .claude/commands). Trust this folder and load them?");
-                writeTrustDecision(deps.agentDir, deps.cwd, trusted);
-            }
-            catch {
-                trusted = null;
-            }
+    let trusted = projectTrust;
+    if (decision.needsPrompt && deps.confirm) {
+        try {
+            trusted = await deps.confirm("This folder has Claude Code assets (.claude skills, commands, rules, or plugins). Trust this folder and load them?");
+            writeTrustDecision(deps.agentDir, deps.cwd, trusted);
+        }
+        catch {
+            trusted = null;
         }
-        if (trusted === true)
-            argv.push(...decision.projectArgv);
     }
-    return argv;
+    const argv = [...decision.userArgv];
+    if (trusted === true)
+        argv.push(...decision.projectArgv);
+    const agentDirs = [
+        ...decision.userAgentDirs,
+        ...(trusted === true ? decision.projectAgentDirs : []),
+    ];
+    // User rules first, project rules last: the extension appends in order, so
+    // project rules end up closest to the task — matching Claude Code priority.
+    const rulesDirs = [
+        ...decision.userRulesDirs,
+        ...(trusted === true ? decision.projectRulesDirs : []),
+    ];
+    const extraEnv = {};
+    if (agentDirs.length > 0)
+        extraEnv[CLAUDE_AGENT_DIRS_ENV] = agentDirs.join(delimiter);
+    if (rulesDirs.length > 0)
+        extraEnv[CLAUDE_RULES_DIRS_ENV] = rulesDirs.join(delimiter);
+    return { argv, env: extraEnv };
 }
 /** Whether pi's trust file exists yet (used only for messaging). */
 export function trustFileExists(agentDir) {

package/dist/claudePlugins.d.ts

@@ -0,0 +1,109 @@
+/**
+ * Claude Code plugin + marketplace discovery (local content only).
+ *
+ * Finds the plugin content a Claude Code user already has on disk and exposes
+ * it as asset paths the launcher can feed through the existing compat seams:
+ * skills → `--skill`, commands → `--prompt-template`, agents → the subagent
+ * discovery env var. Two sources:
+ *
+ * 1. Installed plugins: `~/.claude/plugins/installed_plugins.json` (version-2
+ *    ledger of `name@marketplace` → cache checkouts), enabled through
+ *    `enabledPlugins` in the user's `~/.claude/settings.json` (user scope) or
+ *    the repo's `.claude/settings{,.local}.json` (project scope). When a
+ *    ledger entry is gone, the marketplace checkout recorded in
+ *    `known_marketplaces.json` is tried as a fallback.
+ * 2. The repo's own `.claude-plugin/marketplace.json` (the internal-
+ *    marketplace pattern): every plugin it defines with a locally-present
+ *    relative-path source loads on the project side, unless explicitly
+ *    disabled via `enabledPlugins`.
+ *
+ * Deliberately NOT here: network installation of any kind, plugin hooks, MCP
+ * servers, LSP servers, themes, output styles. Discovery is read-only.
+ *
+ * Everything is fail-soft: malformed JSON, missing dirs, or hostile path
+ * entries degrade to "that plugin absent" — never a failed launch. Path
+ * entries from marketplace/plugin manifests are containment-checked (realpath
+ * inside the expected root) so a malicious `source` or component override
+ * cannot reach outside its repo/plugin.
+ */
+export interface PluginAssets {
+    /** The plugin's name (marketplace-entry name — the `enabledPlugins` key half). */
+    name: string;
+    /** Absolute plugin root directory. */
+    root: string;
+    /** Dirs (or a lone root SKILL.md file) for pi `--skill`. */
+    skillPaths: string[];
+    /** Dirs or files for pi `--prompt-template`. */
+    commandPaths: string[];
+    /** Dirs of Claude Code-format agent markdown for subagent discovery. */
+    agentDirs: string[];
+}
+export interface DiscoveredClaudePlugins {
+    /** Enabled via the user's own `~/.claude` config; loads without ceremony. */
+    user: PluginAssets[];
+    /** Sourced from repo config; wire only once the folder is trusted. */
+    project: PluginAssets[];
+}
+/**
+ * Resolve `candidate` (a relative path from untrusted JSON) against `root` and
+ * return its realpath only when it exists AND stays inside `root` after
+ * symlink resolution. Absolute candidates and any `../` escape are rejected.
+ */
+export declare function containedExistingPath(root: string, candidate: string): string | null;
+export interface InstalledPluginEntry {
+    installPath: string;
+    projectPath?: string;
+}
+/** `~/.claude/plugins/installed_plugins.json` → `name@marketplace` → entries. */
+export declare function readInstalledPlugins(homeDir: string): Map<string, InstalledPluginEntry[]>;
+export type EnableScope = "user" | "project";
+export interface EnableState {
+    enabled: boolean;
+    scope: EnableScope;
+}
+/**
+ * `enabledPlugins` merged across scopes, later (more specific) winning:
+ * user `~/.claude/settings.json` < project `.claude/settings.json` <
+ * project `.claude/settings.local.json`.
+ */
+export declare function readEnabledPlugins(cwd: string, homeDir: string): Map<string, EnableState>;
+/** `~/.claude/plugins/known_marketplaces.json` → marketplace name → checkout dir. */
+export declare function readKnownMarketplaces(homeDir: string): Map<string, string>;
+export interface MarketplaceEntry {
+    name: string;
+    source: unknown;
+}
+export interface Marketplace {
+    name: string;
+    /** Marketplace root: the dir containing `.claude-plugin/`. */
+    root: string;
+    /** `metadata.pluginRoot`, prepended to bare relative sources. */
+    pluginRoot: string | null;
+    plugins: MarketplaceEntry[];
+}
+/** Parse `<root>/.claude-plugin/marketplace.json`; null when absent/unusable. */
+export declare function readMarketplace(root: string): Marketplace | null;
+/**
+ * The local directory a marketplace entry's source points at, when it is a
+ * relative-path source that exists inside the marketplace root. Object
+ * sources (github/url/npm/...) are network installs → null here.
+ */
+export declare function resolveLocalPluginRoot(mp: Marketplace, entry: MarketplaceEntry): string | null;
+/**
+ * The bridgeable assets inside one plugin checkout, per Claude Code's
+ * component rules: `skills/` (manifest `skills` ADDS dirs), `commands/`
+ * (manifest REPLACES), `agents/` (manifest REPLACES; dirs only — pi's
+ * discovery reads whole dirs), root `SKILL.md` fallback. Null when the plugin
+ * has nothing we can bridge.
+ */
+export declare function pluginAssets(root: string, name: string): PluginAssets | null;
+export interface DiscoverPluginsDeps {
+    cwd: string;
+    homeDir: string;
+}
+/**
+ * All locally-present Claude Code plugin content relevant to `cwd`, split by
+ * the trust posture the launcher must apply. Never throws.
+ */
+export declare function discoverClaudePlugins(deps: DiscoverPluginsDeps): DiscoveredClaudePlugins;
+//# sourceMappingURL=claudePlugins.d.ts.map