@yagni-app/code 1.0.6 → 1.0.8

package/dist/otel.js

@@ -1,54 +1,72 @@
 /**
- * OTel export wiring (Updater pilot ask): bake the `pi-otel` extension into
- * every launch so a workspace can stream session traces — token usage, cost,
- * model tier, tool calls — to its own OTLP collector (e.g. Datadog) without
- * anyone hand-installing an extension.
+ * OTel export gate (Updater pilot ask, now Claude Code parity): decide
+ * whether a launch streams session telemetry — traces, metrics, and log
+ * events — to the workspace's own OTLP collector (Datadog, Grafana, an
+ * in-house collector), and hand the session the standard OpenTelemetry env
+ * it needs. The exporter itself lives in the bundled extension
+ * (`pi-extension-yagni/src/telemetry`), so there is nothing extra to load and
+ * nothing that can go missing on a customer's `npm install`.
  *
- * Three deliberate policies, all enforced here rather than left to defaults:
+ * Three deliberate policies, enforced here rather than left to defaults:
  *
- * 1. GATED, not always-on. pi-otel ships `enabled: true` pointed at
- *    `localhost:4317`, so loading it unconditionally would have every session
- *    probing a collector nobody runs. We only pass the extension to pi when an
- *    OTLP endpoint is actually configured: `OTEL_EXPORTER_OTLP_ENDPOINT` in the
- *    environment, or `otel.endpoint` in the repo's committed `.pi/settings.json`
- *    (the file pi-otel itself reads, so teams can configure once per repo).
+ * 1. GATED, not always-on. Nothing exports unless an OTLP destination is
+ *    configured: the user's own OTEL_* env, the workspace's admin-set config
+ *    (fetched fail-soft and cached), or the repo's committed
+ *    `.pi/settings.json`. The gate result travels to the session as
+ *    `YAGNI_OTEL_EXPORT=1` plus the OTLP variables; children (/go stages,
+ *    subagents) inherit the env and export too.
  *
- * 2. METADATA-ONLY, enforced. Cost, tokens, model, finish reasons and tool-call
- *    ids export; prompt and response text never do. `PI_OTEL_CAPTURE_CONTENT`
- *    is pinned in the child env, and env beats settings in pi-otel's own
- *    precedence — a repo settings file asking for "full" is overridden, not
- *    honored. Session content leaving the machine is a contract change, not a
- *    config knob.
+ * 2. METADATA-ONLY, in code. Token counts, cost, tier, durations, tool names,
+ *    and sizes export; prompt, response, and tool content never do. The
+ *    extension enforces this without a knob — no env var re-enables content.
  *
- * 3. Cost is the customer's SELL rate. pi-otel exports pi's `usage.cost.total`
- *    verbatim (as `pi.cost.usd`), and pi computes that from the catalog's
- *    tier rates (YAG-381) — so the collector sees contracted prices, and the
- *    exported model name is the opaque tier id, never the backing model.
+ * 3. Cost is the customer's SELL rate. Usage cost is pi's `usage.cost.total`,
+ *    computed from the catalog's tier rates (YAG-381), and the exported model
+ *    name is the opaque tier id, never the backing model.
  *
- * Everything here is fail-soft: telemetry must never block a launch, so a
- * missing package or unreadable settings file resolves to "disabled".
+ * Everything here is fail-soft: telemetry must never block a launch, so an
+ * unreadable settings file or an offline backend resolves to "disabled" or
+ * to last-known config.
  */
-import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
-import { createConnection } from "node:net";
+import { mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
-import { fileURLToPath } from "node:url";
 import { credentialsDir } from "./credentials.js";
-/**
- * Env var carrying the resolved pi-otel entry path to /go stage children and
- * subagents: they build their own pi argv inside pi-extension-yagni (which
- * cannot import this package), so the path crosses over env. The extension
- * reads the same literal in `pipeline/runner.ts`.
- */
-export const OTEL_EXTENSION_PATH_ENV = "YAGNI_OTEL_EXTENSION_PATH";
+/** The launcher's "this session exports" gate, read by the bundled extension. */
+export const OTEL_EXPORT_ENV = "YAGNI_OTEL_EXPORT";
 /** The service name a collector sees unless the user set their own. */
 export const DEFAULT_OTEL_SERVICE_NAME = "yagni-code";
 /**
- * Read `otel.endpoint` from the repo's `.pi/settings.json`, the project-level
- * file pi-otel itself resolves config from. Returns undefined on any problem —
- * a malformed settings file must not block a launch (pi-otel will surface its
- * own complaint in-session).
+ * Headers that belong on the TRACES request only. Datadog's LLM Observability
+ * routes OTLP traces to its LLM product when `dd-otlp-source=llmobs` rides
+ * along; the same header on the metrics and logs intakes is meaningless at
+ * best, so the launcher scopes it to `OTEL_EXPORTER_OTLP_TRACES_HEADERS`.
+ */
+const TRACE_ONLY_HEADERS = new Set(["dd-otlp-source"]);
+/** The standard per-signal endpoint variables, generic first (its precedence). */
+const ENDPOINT_ENV_VARS = [
+    "OTEL_EXPORTER_OTLP_ENDPOINT",
+    "OTEL_EXPORTER_OTLP_TRACES_ENDPOINT",
+    "OTEL_EXPORTER_OTLP_METRICS_ENDPOINT",
+    "OTEL_EXPORTER_OTLP_LOGS_ENDPOINT",
+];
+/** Trailing `/v1/<signal>` on a URL — the shape pre-parity configs stored. */
+const SIGNAL_PATH_RE = /\/v1\/(traces|metrics|logs)\/?$/i;
+/**
+ * Reduce an endpoint that carries a signal path to its base
+ * (`https://otlp.datadoghq.com/v1/traces` → `https://otlp.datadoghq.com`).
+ * The extension appends `/v1/<signal>` per signal for http transports, so a
+ * workspace config saved before logs and metrics existed keeps exporting all
+ * three without an admin re-save. Mirrors the extension's own helper.
+ */
+export function stripSignalPath(endpoint) {
+    return endpoint.replace(SIGNAL_PATH_RE, "").replace(/\/+$/, "");
+}
+/**
+ * Read the `otel` block from the repo's `.pi/settings.json`, the project-level
+ * file a team commits once so every clone exports. Returns undefined on any
+ * problem — a malformed settings file must not block a launch.
  */
-function projectOtelEndpoint(cwd, readFile) {
+function projectOtelSettings(cwd, readFile) {
     try {
         const raw = readFile(join(cwd, ".pi", "settings.json"), "utf8");
         const parsed = JSON.parse(String(raw));
@@ -57,167 +75,126 @@ function projectOtelEndpoint(cwd, readFile) {
         const otel = parsed.otel;
         if (typeof otel !== "object" || otel === null)
             return undefined;
-        const endpoint = otel.endpoint;
-        return typeof endpoint === "string" && endpoint.trim() !== "" ? endpoint.trim() : undefined;
+        const o = otel;
+        if (o.enabled === false)
+            return undefined;
+        const endpoint = typeof o.endpoint === "string" && o.endpoint.trim() !== "" ? o.endpoint.trim() : undefined;
+        if (!endpoint)
+            return undefined;
+        const headers = {};
+        if (typeof o.headers === "object" && o.headers !== null) {
+            for (const [k, v] of Object.entries(o.headers)) {
+                // Headers travel to the session as the comma-separated
+                // OTEL_EXPORTER_OTLP_HEADERS list; a comma in a value would corrupt
+                // every pair after it, so such a header is dropped (same rule the
+                // workspace settings enforce at save time).
+                if (typeof v === "string" && !v.includes(",") && !k.includes(","))
+                    headers[k] = v;
+            }
+        }
+        return {
+            endpoint,
+            ...(typeof o.protocol === "string" && o.protocol.trim() ? { protocol: o.protocol.trim() } : {}),
+            ...(Object.keys(headers).length > 0 ? { headers } : {}),
+            ...(typeof o.serviceName === "string" && o.serviceName.trim() ? { serviceName: o.serviceName.trim() } : {}),
+        };
     }
     catch {
         return undefined;
     }
 }
-/** Truthy per pi-otel's own convention for PI_OTEL_DISABLED. */
-function envDisabled(env) {
-    return env.PI_OTEL_DISABLED === "1" || env.PI_OTEL_DISABLED === "true";
+/** Personal kill switch: beats every source. Both spellings accepted. */
+export function envDisabled(env) {
+    const truthy = (v) => v === "1" || v === "true";
+    return truthy(env.PI_OTEL_DISABLED) || truthy(env.YAGNI_OTEL_DISABLED);
+}
+/** The first configured endpoint variable in the user's env, generic first. */
+function envEndpoint(env) {
+    for (const envVar of ENDPOINT_ENV_VARS) {
+        const value = env[envVar]?.trim();
+        if (value)
+            return { envVar, endpoint: value };
+    }
+    return undefined;
 }
 /**
- * Decide whether this launch exports OTel traces, and with which pi-otel entry.
- * Returns undefined when export stays off: no endpoint configured anywhere,
- * `PI_OTEL_DISABLED` set, or the pi-otel package unresolvable (never fatal).
+ * Decide whether this launch exports, from the user's env and the repo's
+ * settings. Returns undefined when export stays off: no endpoint configured,
+ * or a kill switch set.
  *
- * Env sources, in precedence order: the generic `OTEL_EXPORTER_OTLP_ENDPOINT`,
- * then the per-signal `OTEL_EXPORTER_OTLP_TRACES_ENDPOINT`. pi-otel only reads
- * the generic var, so the per-signal one (the standard OTel env shape, and
- * what Claude Code setups configure — e.g. Updater's) is bridged: the traces
- * endpoint becomes the generic one, and a per-signal TRACES_PROTOCOL carries
- * over the same way. Logs/metrics per-signal vars are deliberately NOT read:
- * sessions export traces only, and pi-otel's metrics/logs signals are opt-in
- * elsewhere.
+ * Any of the standard endpoint variables enables export — the generic
+ * `OTEL_EXPORTER_OTLP_ENDPOINT` or a per-signal one — so a machine that
+ * carries a Claude Code telemetry env (typically all three per-signal
+ * endpoints) lights up with no translation. The extension reads the same
+ * variables, per signal, following the OTLP exporter spec.
  */
 export function resolveOtelLaunch(opts) {
     const { env, cwd } = opts;
     if (envDisabled(env))
         return undefined;
-    const envEndpoint = env.OTEL_EXPORTER_OTLP_ENDPOINT?.trim();
-    const tracesEndpoint = env.OTEL_EXPORTER_OTLP_TRACES_ENDPOINT?.trim();
-    const usingPerSignal = !envEndpoint && !!tracesEndpoint;
-    const settingsEndpoint = envEndpoint || tracesEndpoint ? undefined : projectOtelEndpoint(cwd, opts.readFile ?? readFileSync);
-    if (!envEndpoint && !tracesEndpoint && !settingsEndpoint)
+    const fromEnv = envEndpoint(env);
+    if (fromEnv)
+        return { source: "env", envVar: fromEnv.envVar, endpoint: fromEnv.endpoint };
+    const settings = projectOtelSettings(cwd, opts.readFile ?? readFileSync);
+    if (!settings)
         return undefined;
-    let extensionPath;
-    try {
-        extensionPath = (opts.resolveExtension ?? resolveOtelExtensionPath)();
-    }
-    catch {
-        return undefined;
-    }
-    if (envEndpoint) {
-        return {
-            extensionPath,
-            source: "env",
-            envVar: "OTEL_EXPORTER_OTLP_ENDPOINT",
-            endpoint: envEndpoint,
-        };
-    }
-    if (usingPerSignal) {
-        return {
-            extensionPath,
-            source: "env",
-            envVar: "OTEL_EXPORTER_OTLP_TRACES_ENDPOINT",
-            endpoint: tracesEndpoint,
-            ...(env.OTEL_EXPORTER_OTLP_TRACES_PROTOCOL?.trim()
-                ? { protocol: env.OTEL_EXPORTER_OTLP_TRACES_PROTOCOL.trim() }
-                : {}),
-        };
-    }
-    return { extensionPath, source: "project-settings", endpoint: settingsEndpoint };
+    return {
+        source: "project-settings",
+        endpoint: settings.endpoint,
+        ...(settings.protocol ? { protocol: settings.protocol } : {}),
+        ...(settings.headers ? { headers: settings.headers } : {}),
+        ...(settings.serviceName ? { serviceName: settings.serviceName } : {}),
+    };
 }
-/** Absolute path to pi-otel's extension entry (its package main IS the pi
- * extension entry, `dist/index.js`). Resolved ESM-native like `paths.ts` does
- * for pi itself. Throws when the package is missing — callers treat that as
- * "export off", not an error.
- */
-export function resolveOtelExtensionPath() {
-    const path = fileURLToPath(import.meta.resolve("pi-otel"));
-    if (!existsSync(path)) {
-        throw new Error(`pi-otel entry not found at ${path}`);
-    }
-    return path;
+/** Render a header record as the comma-separated `k=v` list the OTel env carries. */
+function headerList(headers) {
+    return Object.entries(headers)
+        .map(([k, v]) => `${k}=${v}`)
+        .join(",");
 }
 /**
- * TCP reachability probe for an OTLP endpoint URL, with scheme-default ports:
- * WHATWG `URL` strips `:443`/`:80` as defaults, so an https endpoint with no
- * port probes 443 (the agentless SaaS shape). Returns false on any parse or
- * connect failure — reachability is advisory, never fatal. Mirrors the probe
- * inside (patched) pi-otel but lives here so `doctor` can use it without
- * importing the extension's SDK graph.
- */
-export async function probeOtelEndpoint(endpoint, timeoutMs = 1_000) {
-    let host;
-    let port;
-    try {
-        const u = new URL(endpoint);
-        host = u.hostname;
-        port = u.port
-            ? Number(u.port)
-            : u.protocol === "https:"
-                ? 443
-                : u.protocol === "http:"
-                    ? 80
-                    : null;
-    }
-    catch {
-        return false;
-    }
-    if (!host || !port)
-        return false;
-    return new Promise((resolve) => {
-        const sock = createConnection({ host, port });
-        const done = (ok) => {
-            sock.destroy();
-            resolve(ok);
-        };
-        sock.setTimeout(timeoutMs);
-        sock.once("connect", () => done(true));
-        sock.once("timeout", () => done(false));
-        sock.once("error", () => done(false));
-    });
-}
-/**
- * The env keys an OTel-exporting child must carry. `PI_OTEL_CAPTURE_CONTENT`
- * is pinned unconditionally (policy 2 above); the service name only fills in
- * when the user has not chosen their own.
+ * The env keys an exporting child must carry. `YAGNI_OTEL_EXPORT=1` is the
+ * gate the extension reads; the service name only fills in when the user has
+ * not chosen their own.
  *
- * A "workspace"-sourced config additionally delivers the admin-set endpoint,
- * protocol, and collector headers over the standard OTel env vars — but any
- * of those the USER already set in their own environment wins (local env >
- * workspace config), so an engineer can point one session at a scratch
- * collector without an admin change.
+ * A "workspace" or "project-settings" config delivers its endpoint (as the
+ * generic BASE endpoint — the extension derives the per-signal URLs),
+ * protocol, headers, and service name over the standard OTel env vars — but
+ * any of those the USER already set in their own environment wins (local
+ * env > workspace config), so an engineer can point one session at a
+ * scratch collector without an admin change. An "env" config is the user's
+ * own setup and passes through untouched.
  */
 export function otelChildEnv(config, baseEnv) {
-    const workspace = {};
-    if (config.source === "workspace") {
-        if (!baseEnv.OTEL_EXPORTER_OTLP_ENDPOINT) {
-            workspace.OTEL_EXPORTER_OTLP_ENDPOINT = config.endpoint;
+    const out = {};
+    if (config.source === "workspace" || config.source === "project-settings") {
+        const userHasEndpoint = ENDPOINT_ENV_VARS.some((v) => baseEnv[v]?.trim());
+        if (!userHasEndpoint) {
+            out.OTEL_EXPORTER_OTLP_ENDPOINT = stripSignalPath(config.endpoint);
         }
         if (config.protocol && !baseEnv.OTEL_EXPORTER_OTLP_PROTOCOL) {
-            workspace.OTEL_EXPORTER_OTLP_PROTOCOL = config.protocol;
+            out.OTEL_EXPORTER_OTLP_PROTOCOL = config.protocol;
         }
         if (config.headers && Object.keys(config.headers).length > 0 && !baseEnv.OTEL_EXPORTER_OTLP_HEADERS) {
-            workspace.OTEL_EXPORTER_OTLP_HEADERS = Object.entries(config.headers)
-                .map(([k, v]) => `${k}=${v}`)
-                .join(",");
+            const shared = {};
+            const traceOnly = {};
+            for (const [k, v] of Object.entries(config.headers)) {
+                (TRACE_ONLY_HEADERS.has(k.toLowerCase()) ? traceOnly : shared)[k] = v;
+            }
+            if (Object.keys(shared).length > 0)
+                out.OTEL_EXPORTER_OTLP_HEADERS = headerList(shared);
+            if (Object.keys(traceOnly).length > 0 && !baseEnv.OTEL_EXPORTER_OTLP_TRACES_HEADERS) {
+                out.OTEL_EXPORTER_OTLP_TRACES_HEADERS = headerList(traceOnly);
+            }
         }
         if (config.serviceName && !baseEnv.OTEL_SERVICE_NAME) {
-            workspace.OTEL_SERVICE_NAME = config.serviceName;
-        }
-    }
-    else if (config.source === "env" && config.protocol) {
-        // The per-signal bridge: the endpoint came from
-        // OTEL_EXPORTER_OTLP_TRACES_ENDPOINT (+ TRACES_PROTOCOL), which pi-otel
-        // does not read — deliver them as the generic vars the extension resolves.
-        if (!baseEnv.OTEL_EXPORTER_OTLP_ENDPOINT) {
-            workspace.OTEL_EXPORTER_OTLP_ENDPOINT = config.endpoint;
-        }
-        if (!baseEnv.OTEL_EXPORTER_OTLP_PROTOCOL) {
-            workspace.OTEL_EXPORTER_OTLP_PROTOCOL = config.protocol;
+            out.OTEL_SERVICE_NAME = config.serviceName;
         }
     }
     return {
-        ...workspace,
-        [OTEL_EXTENSION_PATH_ENV]: config.extensionPath,
-        PI_OTEL_CAPTURE_CONTENT: "metadata_only",
-        ...(baseEnv.OTEL_SERVICE_NAME || workspace.OTEL_SERVICE_NAME
-            ? {}
-            : { OTEL_SERVICE_NAME: DEFAULT_OTEL_SERVICE_NAME }),
+        ...out,
+        [OTEL_EXPORT_ENV]: "1",
+        ...(baseEnv.OTEL_SERVICE_NAME || out.OTEL_SERVICE_NAME ? {} : { OTEL_SERVICE_NAME: DEFAULT_OTEL_SERVICE_NAME }),
     };
 }
 // ── Workspace-configured export (admin sets it once in the web app) ─────────
@@ -313,10 +290,8 @@ function readWorkspaceOtelCache(cachePath) {
 /**
  * Full launch-time resolution, all four sources in precedence order:
  *
- *   1. `PI_OTEL_DISABLED`      — personal kill switch, beats everything.
- *   2. env `OTEL_EXPORTER_OTLP_ENDPOINT` / `OTEL_EXPORTER_OTLP_TRACES_ENDPOINT`
- *                              — the user's own setup, untouched (generic wins
- *                              over per-signal).
+ *   1. `PI_OTEL_DISABLED` / `YAGNI_OTEL_DISABLED` — personal kill switch.
+ *   2. env `OTEL_EXPORTER_OTLP_*_ENDPOINT` — the user's own setup, untouched.
  *   3. workspace config        — admin-set in the web app, fetched/cached.
  *   4. repo `.pi/settings.json` — committed per-repo config.
  *
@@ -327,27 +302,14 @@ export async function resolveOtelLaunchWithWorkspace(opts) {
     if (envDisabled(env))
         return undefined;
     // Source 2: the user's own env config short-circuits — no fetch needed.
-    if (env.OTEL_EXPORTER_OTLP_ENDPOINT?.trim() || env.OTEL_EXPORTER_OTLP_TRACES_ENDPOINT?.trim()) {
-        return resolveOtelLaunch({
-            env,
-            cwd,
-            ...(opts.resolveExtension ? { resolveExtension: opts.resolveExtension } : {}),
-            ...(opts.readFile ? { readFile: opts.readFile } : {}),
-        });
+    if (envEndpoint(env)) {
+        return resolveOtelLaunch({ env, cwd, ...(opts.readFile ? { readFile: opts.readFile } : {}) });
     }
     // Source 3: workspace config.
     if (opts.creds?.token && opts.profileName) {
         const workspace = await (opts.fetchWorkspace ?? fetchWorkspaceOtel)({ baseUrl: opts.creds.baseUrl, token: opts.creds.token }, opts.profileName, opts.fetchDeps ?? {});
         if (workspace) {
-            let extensionPath;
-            try {
-                extensionPath = (opts.resolveExtension ?? resolveOtelExtensionPath)();
-            }
-            catch {
-                return undefined;
-            }
             return {
-                extensionPath,
                 source: "workspace",
                 endpoint: workspace.endpoint,
                 ...(workspace.protocol ? { protocol: workspace.protocol } : {}),
@@ -359,11 +321,6 @@ export async function resolveOtelLaunchWithWorkspace(opts) {
         }
     }
     // Source 4: repo-committed settings.
-    return resolveOtelLaunch({
-        env,
-        cwd,
-        ...(opts.resolveExtension ? { resolveExtension: opts.resolveExtension } : {}),
-        ...(opts.readFile ? { readFile: opts.readFile } : {}),
-    });
+    return resolveOtelLaunch({ env, cwd, ...(opts.readFile ? { readFile: opts.readFile } : {}) });
 }
 //# sourceMappingURL=otel.js.map

package/dist/paths.d.ts

@@ -19,6 +19,12 @@
  * fall back to resolving the workspace-linked package, which keeps `pnpm test`
  * and a fresh checkout working before anything is bundled.
  */
+/**
+ * Absolute path to this CLI's entry (`dist/cli.js`). Forwarded to sessions as
+ * `YAGNI_CLI_PATH` so the extension's `/plugin` panel can run
+ * `yagni plugin …` with the exact binary that launched it.
+ */
+export declare function resolveCliPath(): string;
 export declare function resolveExtensionPath(): string;
 /**
  * Absolute path to the extension's headless pipeline entry
@@ -29,6 +35,13 @@ export declare function resolveExtensionPath(): string;
  * it pulls in the pipeline alone, with none of pi's TUI surface.
  */
 export declare function resolveHeadlessGoPath(): string;
+/**
+ * Absolute path to the extension's telemetry probe (`telemetry/probe.js`),
+ * the module `yagni doctor` imports to send one real record per signal.
+ * Same derivation as `resolveHeadlessGoPath`; only this module (and the OTel
+ * SDK it pulls in) loads, none of pi's TUI surface.
+ */
+export declare function resolveTelemetryProbePath(): string;
 /**
  * Absolute path to the extension's session-worktree entry
  * (`pipeline/sessionWorktree.js`), the module `yagni -w` imports.

package/dist/paths.js

@@ -25,6 +25,14 @@ function resolveModulePath(specifier) {
  * fall back to resolving the workspace-linked package, which keeps `pnpm test`
  * and a fresh checkout working before anything is bundled.
  */
+/**
+ * Absolute path to this CLI's entry (`dist/cli.js`). Forwarded to sessions as
+ * `YAGNI_CLI_PATH` so the extension's `/plugin` panel can run
+ * `yagni plugin …` with the exact binary that launched it.
+ */
+export function resolveCliPath() {
+    return fileURLToPath(new URL("./cli.js", import.meta.url));
+}
 export function resolveExtensionPath() {
     const bundled = fileURLToPath(new URL("./extension/index.js", import.meta.url));
     if (existsSync(bundled))
@@ -43,6 +51,16 @@ export function resolveHeadlessGoPath() {
     const entry = resolveExtensionPath();
     return join(dirname(entry), "pipeline", "headlessGo.js");
 }
+/**
+ * Absolute path to the extension's telemetry probe (`telemetry/probe.js`),
+ * the module `yagni doctor` imports to send one real record per signal.
+ * Same derivation as `resolveHeadlessGoPath`; only this module (and the OTel
+ * SDK it pulls in) loads, none of pi's TUI surface.
+ */
+export function resolveTelemetryProbePath() {
+    const entry = resolveExtensionPath();
+    return join(dirname(entry), "telemetry", "probe.js");
+}
 /**
  * Absolute path to the extension's session-worktree entry
  * (`pipeline/sessionWorktree.js`), the module `yagni -w` imports.

package/dist/pluginCommand.d.ts

@@ -0,0 +1,43 @@
+/**
+ * `yagni plugin …` — install, remove, and update Claude Code plugins from
+ * marketplaces without leaving YAGNI Code, mirroring Claude Code's own
+ * `claude plugin` surface (marketplace add/list/update/remove, install,
+ * uninstall, enable, disable, update, list).
+ *
+ * State lives in YAGNI's own ledger (pluginStore.ts). Plugins Claude Code
+ * installed are still mirrored read-only (claudePlugins.ts) and show up in
+ * `list` labelled as such, so a developer sees one honest inventory: what
+ * loads, where it came from, and which components (hooks) are not bridged.
+ */
+import { type PluginAssets } from "./claudePlugins.js";
+import { type GitRunner, type PluginInstallScope } from "./pluginStore.js";
+export interface PluginCommandDeps {
+    cwd?: string;
+    /** The user's home dir (`~`); the ledger lives under `$YAGNI_CODE_HOME` or `~/.yagni-code`. */
+    home?: string;
+    env?: NodeJS.ProcessEnv;
+    git?: GitRunner;
+    stdout?: (text: string) => void;
+    stderr?: (text: string) => void;
+    /** pi agent dir holding trust.json (defaults to the active profile's). */
+    agentDir?: () => Promise<string>;
+    now?: () => Date;
+}
+export interface ParsedPluginArgs {
+    subcommand: string | undefined;
+    positionals: string[];
+    scope: PluginInstallScope;
+    scopeExplicit: boolean;
+    available: boolean;
+    json: boolean;
+}
+export declare function parsePluginArgs(args: string[]): ParsedPluginArgs;
+/** The repo root a project-scope install applies to: nearest `.git` ancestor, else cwd. */
+export declare function resolveRepoRoot(cwd: string): string;
+export declare function pluginCommand(args: string[], deps?: PluginCommandDeps): Promise<number>;
+export declare function componentSummary(p: PluginAssets): string;
+/** Whether a stdio `command` resolves on PATH (or is an existing path). Unknown when it has an unexpanded ${VAR}. */
+export declare function commandOnPath(command: string, env: NodeJS.ProcessEnv): boolean | null;
+/** Per-server notes for a plugin's MCP block: names, and a missing-binary warning for stdio servers. */
+export declare function mcpNotes(p: PluginAssets, env: NodeJS.ProcessEnv): string[];
+//# sourceMappingURL=pluginCommand.d.ts.map