jinzd-ai-cli 0.4.217 → 0.4.219

package/dist/chunk-GGKQHPB3.js

@@ -0,0 +1,604 @@
+#!/usr/bin/env node
+import {
+  CONFIG_DIR_NAME,
+  PLUGINS_DIR_NAME
+} from "./chunk-U7KVU25H.js";
+import {
+  atomicWriteFileSync
+} from "./chunk-IW3Q7AE5.js";
+
+// src/diagnostics/tool-stats.ts
+import { existsSync, readFileSync, mkdirSync } from "fs";
+import { join, dirname } from "path";
+import { homedir } from "os";
+var STATS_FILE_NAME = "tool-stats.json";
+var STATS_VERSION = 1;
+var FLUSH_EVERY_N = 50;
+var state = null;
+var dirty = false;
+var pendingWrites = 0;
+var configDirOverride;
+function statsFilePath() {
+  const base = configDirOverride ?? join(homedir(), CONFIG_DIR_NAME);
+  return join(base, STATS_FILE_NAME);
+}
+function load() {
+  const path = statsFilePath();
+  if (!existsSync(path)) {
+    return { version: STATS_VERSION, startedAt: (/* @__PURE__ */ new Date()).toISOString(), entries: {} };
+  }
+  try {
+    const raw = JSON.parse(readFileSync(path, "utf-8"));
+    if (raw.version !== STATS_VERSION || !raw.entries) {
+      return { version: STATS_VERSION, startedAt: (/* @__PURE__ */ new Date()).toISOString(), entries: {} };
+    }
+    return raw;
+  } catch {
+    return { version: STATS_VERSION, startedAt: (/* @__PURE__ */ new Date()).toISOString(), entries: {} };
+  }
+}
+function ensureLoaded() {
+  if (state === null) state = load();
+  return state;
+}
+function recordToolCall(name, durationMs, ok, errorMessage) {
+  const s = ensureLoaded();
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  let entry = s.entries[name];
+  if (!entry) {
+    entry = {
+      name,
+      calls: 0,
+      failures: 0,
+      totalDurationMs: 0,
+      firstSeenAt: now,
+      lastUsedAt: now
+    };
+    s.entries[name] = entry;
+  }
+  entry.calls += 1;
+  entry.totalDurationMs += Math.max(0, Math.round(durationMs));
+  entry.lastUsedAt = now;
+  if (!ok) {
+    entry.failures += 1;
+    entry.lastFailureAt = now;
+    if (errorMessage) entry.lastFailureMessage = errorMessage.slice(0, 300);
+  }
+  dirty = true;
+  pendingWrites += 1;
+  if (pendingWrites >= FLUSH_EVERY_N) {
+    flush();
+  }
+}
+async function runTool(tool, args, name) {
+  const start = Date.now();
+  try {
+    const result = await tool.execute(args);
+    recordToolCall(name, Date.now() - start, true);
+    return result;
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    recordToolCall(name, Date.now() - start, false, msg);
+    throw err;
+  }
+}
+function flush() {
+  if (!dirty || state === null) return;
+  const path = statsFilePath();
+  try {
+    mkdirSync(dirname(path), { recursive: true });
+    atomicWriteFileSync(path, JSON.stringify(state, null, 2));
+    dirty = false;
+    pendingWrites = 0;
+  } catch {
+  }
+}
+function getStatsSnapshot() {
+  const s = ensureLoaded();
+  return Object.values(s.entries).map((e) => ({ ...e }));
+}
+function getTopFailingTools(limit = 5) {
+  return getStatsSnapshot().filter((e) => e.failures > 0).sort((a, b) => {
+    const rateA = a.failures / Math.max(1, a.calls);
+    const rateB = b.failures / Math.max(1, b.calls);
+    if (rateB !== rateA) return rateB - rateA;
+    return b.failures - a.failures;
+  }).slice(0, limit);
+}
+function getTopUsedTools(limit = 5) {
+  return getStatsSnapshot().sort((a, b) => b.calls - a.calls).slice(0, limit);
+}
+function resetStats() {
+  state = { version: STATS_VERSION, startedAt: (/* @__PURE__ */ new Date()).toISOString(), entries: {} };
+  dirty = true;
+  flush();
+}
+var exitHookInstalled = false;
+function installFlushOnExit() {
+  if (exitHookInstalled) return;
+  exitHookInstalled = true;
+  process.on("exit", () => flush());
+}
+
+// src/plugins/plugin-manager.ts
+import { existsSync as existsSync2, mkdirSync as mkdirSync2, readdirSync, readFileSync as readFileSync2, cpSync, rmSync, statSync } from "fs";
+import { basename, dirname as dirname2, join as join2, resolve } from "path";
+import { createHash } from "crypto";
+import { z } from "zod";
+var MANIFEST_RELATIVE = ".aicli-plugin/plugin.json";
+var STATE_FILE = "plugin-state.json";
+var HookCommandSchema = z.union([
+  z.string(),
+  z.object({
+    command: z.string(),
+    source: z.enum(["user", "project", "managed"]).optional(),
+    description: z.string().optional(),
+    required: z.boolean().optional(),
+    timeoutMs: z.number().int().min(100).max(3e4).optional(),
+    disabled: z.boolean().optional()
+  }),
+  z.array(z.union([
+    z.string(),
+    z.object({
+      command: z.string(),
+      source: z.enum(["user", "project", "managed"]).optional(),
+      description: z.string().optional(),
+      required: z.boolean().optional(),
+      timeoutMs: z.number().int().min(100).max(3e4).optional(),
+      disabled: z.boolean().optional()
+    })
+  ]))
+]);
+var HookEventNameSchema = z.enum([
+  "SessionStart",
+  "UserPromptSubmit",
+  "PreToolUse",
+  "PermissionRequest",
+  "PostToolUse",
+  "PreCompact",
+  "PostCompact",
+  "Stop",
+  "SubagentStart",
+  "SubagentStop"
+]);
+var McpServerSchema = z.object({
+  command: z.string(),
+  args: z.array(z.string()).default([]),
+  env: z.record(z.string()).optional(),
+  timeout: z.number().default(3e4)
+});
+var PluginManifestSchema = z.object({
+  name: z.string().regex(/^[a-zA-Z0-9._-]{1,80}$/),
+  version: z.string().min(1),
+  description: z.string().optional(),
+  skills: z.array(z.string()).default([]),
+  hooks: z.object({
+    enabled: z.boolean().optional(),
+    events: z.record(HookEventNameSchema, HookCommandSchema).default({})
+  }).default({ events: {} }),
+  commands: z.array(z.string()).default([]),
+  mcpServers: z.record(McpServerSchema).default({}),
+  agents: z.array(z.string()).default([]),
+  permissionHints: z.array(z.string()).default([])
+}).strict();
+function pluginRoot(configDir) {
+  return join2(configDir, PLUGINS_DIR_NAME);
+}
+function pluginManifestPath(pluginDir) {
+  return join2(pluginDir, MANIFEST_RELATIVE);
+}
+function statePath(configDir) {
+  return join2(pluginRoot(configDir), STATE_FILE);
+}
+function loadState(configDir) {
+  const file = statePath(configDir);
+  if (!existsSync2(file)) return { version: 1, plugins: [] };
+  try {
+    const parsed = JSON.parse(readFileSync2(file, "utf-8"));
+    return { version: 1, plugins: Array.isArray(parsed.plugins) ? parsed.plugins : [] };
+  } catch {
+    return { version: 1, plugins: [] };
+  }
+}
+function saveState(configDir, state2) {
+  mkdirSync2(pluginRoot(configDir), { recursive: true });
+  atomicWriteFileSync(statePath(configDir), JSON.stringify(state2, null, 2));
+}
+function hashPluginManifest(manifestPath) {
+  return createHash("sha256").update(readFileSync2(manifestPath)).digest("hex");
+}
+function readPluginManifest(manifestPath) {
+  return PluginManifestSchema.parse(JSON.parse(readFileSync2(manifestPath, "utf-8")));
+}
+function findPluginSourceDir(inputPath) {
+  const abs = resolve(inputPath);
+  const direct = statSync(abs).isDirectory() ? abs : dirname2(abs);
+  if (existsSync2(pluginManifestPath(direct))) return direct;
+  const nested = join2(direct, ".aicli-plugin");
+  if (existsSync2(join2(nested, "plugin.json"))) return direct;
+  throw new Error(`plugin manifest not found: ${MANIFEST_RELATIVE}`);
+}
+function installPlugin(configDir, inputPath) {
+  const sourceDir = findPluginSourceDir(inputPath);
+  const manifest = readPluginManifest(pluginManifestPath(sourceDir));
+  const targetDir = join2(pluginRoot(configDir), manifest.name);
+  mkdirSync2(pluginRoot(configDir), { recursive: true });
+  if (existsSync2(targetDir)) rmSync(targetDir, { recursive: true, force: true });
+  cpSync(sourceDir, targetDir, { recursive: true });
+  const manifestPath = pluginManifestPath(targetDir);
+  const hash = hashPluginManifest(manifestPath);
+  const state2 = loadState(configDir);
+  const previous = state2.plugins.find((p) => p.name === manifest.name);
+  const next = {
+    name: manifest.name,
+    enabled: previous?.enabled ?? false,
+    trusted: false,
+    hash,
+    installedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  state2.plugins = [...state2.plugins.filter((p) => p.name !== manifest.name), next];
+  saveState(configDir, state2);
+  return { name: manifest.name, dir: targetDir, manifestPath, manifest, hash, enabled: next.enabled, trusted: false, valid: true };
+}
+function setPluginEnabled(configDir, name, enabled) {
+  const plugin = getInstalledPlugin(configDir, name);
+  if (!plugin.valid) throw new Error(plugin.error ?? `invalid plugin: ${name}`);
+  const state2 = loadState(configDir);
+  const current = state2.plugins.find((p) => p.name === plugin.name) ?? {
+    name: plugin.name,
+    enabled: false,
+    trusted: false,
+    hash: plugin.hash,
+    installedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  const next = { ...current, enabled, hash: plugin.hash, enabledAt: enabled ? (/* @__PURE__ */ new Date()).toISOString() : current.enabledAt };
+  state2.plugins = [...state2.plugins.filter((p) => p.name !== plugin.name), next];
+  saveState(configDir, state2);
+  return next;
+}
+function trustPlugin(configDir, name) {
+  const plugin = getInstalledPlugin(configDir, name);
+  if (!plugin.valid) throw new Error(plugin.error ?? `invalid plugin: ${name}`);
+  const state2 = loadState(configDir);
+  const current = state2.plugins.find((p) => p.name === plugin.name) ?? {
+    name: plugin.name,
+    enabled: false,
+    trusted: false,
+    hash: plugin.hash,
+    installedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  const next = { ...current, trusted: true, hash: plugin.hash, trustedAt: (/* @__PURE__ */ new Date()).toISOString() };
+  state2.plugins = [...state2.plugins.filter((p) => p.name !== plugin.name), next];
+  saveState(configDir, state2);
+  return next;
+}
+function getInstalledPlugin(configDir, name) {
+  const plugins = listInstalledPlugins(configDir);
+  const matches = plugins.filter((p) => p.name === name || p.name.startsWith(name));
+  if (matches.length === 0) throw new Error(`plugin not found: ${name}`);
+  if (matches.length > 1) throw new Error(`plugin name is ambiguous: ${name}`);
+  return matches[0];
+}
+function listInstalledPlugins(configDir) {
+  const root = pluginRoot(configDir);
+  if (!existsSync2(root)) return [];
+  const state2 = loadState(configDir);
+  const out = [];
+  for (const entry of readdirSync(root)) {
+    const dir = join2(root, entry);
+    try {
+      if (!statSync(dir).isDirectory()) continue;
+    } catch {
+      continue;
+    }
+    const manifestPath = pluginManifestPath(dir);
+    if (!existsSync2(manifestPath)) continue;
+    try {
+      const manifest = readPluginManifest(manifestPath);
+      const hash = hashPluginManifest(manifestPath);
+      const st = state2.plugins.find((p) => p.name === manifest.name);
+      const trusted = st?.trusted === true && st.hash === hash;
+      out.push({
+        name: manifest.name,
+        dir,
+        manifestPath,
+        manifest,
+        hash,
+        enabled: st?.enabled === true,
+        trusted,
+        valid: true
+      });
+    } catch (err) {
+      out.push({
+        name: entry,
+        dir,
+        manifestPath,
+        manifest: { name: entry, version: "invalid", skills: [], commands: [], agents: [], hooks: { events: {} }, mcpServers: {}, permissionHints: [] },
+        hash: "",
+        enabled: false,
+        trusted: false,
+        valid: false,
+        error: err instanceof Error ? err.message : String(err)
+      });
+    }
+  }
+  return out.sort((a, b) => a.name.localeCompare(b.name));
+}
+function activePlugins(configDir) {
+  return listInstalledPlugins(configDir).filter((p) => p.valid && p.enabled && p.trusted);
+}
+function uniqueDirs(plugin, rels) {
+  const dirs = /* @__PURE__ */ new Set();
+  for (const rel of rels) {
+    const abs = resolve(plugin.dir, rel);
+    if (!abs.startsWith(resolve(plugin.dir))) continue;
+    if (existsSync2(abs)) dirs.add(statSync(abs).isDirectory() ? abs : dirname2(abs));
+  }
+  return [...dirs];
+}
+function prefixCommand(plugin, command) {
+  return command.replaceAll("{pluginDir}", plugin.dir).replaceAll("$PLUGIN_DIR", plugin.dir);
+}
+function pluginHooks(plugin) {
+  const events = plugin.manifest.hooks?.events ?? {};
+  const out = {};
+  for (const [event, raw] of Object.entries(events)) {
+    const normalize = (item) => {
+      if (typeof item === "string") return { command: prefixCommand(plugin, item), source: "project", description: `plugin:${plugin.name}` };
+      if (item && typeof item === "object") {
+        const obj = item;
+        return { ...obj, command: prefixCommand(plugin, String(obj.command ?? "")), source: "project", description: obj.description ?? `plugin:${plugin.name}` };
+      }
+      return item;
+    };
+    out[event] = Array.isArray(raw) ? raw.map(normalize) : normalize(raw);
+  }
+  return Object.keys(out).length > 0 ? { enabled: plugin.manifest.hooks?.enabled ?? true, events: out } : void 0;
+}
+function mergePluginHooks(base, configDir) {
+  const plugins = activePlugins(configDir);
+  if (plugins.length === 0) return base;
+  const merged = { ...base ?? {}, enabled: base?.enabled ?? true, events: { ...base?.events ?? {} } };
+  for (const plugin of plugins) {
+    const hooks = pluginHooks(plugin);
+    if (!hooks?.events) continue;
+    for (const [event, entry] of Object.entries(hooks.events)) {
+      const key = event;
+      const existing = merged.events?.[key];
+      const existingItems = existing === void 0 ? [] : Array.isArray(existing) ? existing : [existing];
+      const newItems = Array.isArray(entry) ? entry : [entry];
+      merged.events[key] = [...existingItems, ...newItems];
+    }
+  }
+  return merged;
+}
+function getActivePluginAssets(configDir) {
+  const plugins = activePlugins(configDir);
+  const mcpServers = {};
+  const skillDirs = [];
+  const commandDirs = [];
+  const agentDirs = [];
+  for (const plugin of plugins) {
+    skillDirs.push(...uniqueDirs(plugin, plugin.manifest.skills));
+    commandDirs.push(...uniqueDirs(plugin, plugin.manifest.commands));
+    agentDirs.push(...uniqueDirs(plugin, plugin.manifest.agents));
+    for (const [serverName, server] of Object.entries(plugin.manifest.mcpServers)) {
+      mcpServers[`plugin_${plugin.name}_${serverName}`] = server;
+    }
+  }
+  return { plugins, skillDirs, commandDirs, agentDirs, hooks: mergePluginHooks(void 0, configDir), mcpServers };
+}
+function describePlugin(plugin) {
+  const m = plugin.manifest;
+  return [
+    `${plugin.name}@${m.version}`,
+    `  status: ${plugin.enabled ? "enabled" : "disabled"} \xB7 ${plugin.trusted ? "trusted" : "untrusted"}${plugin.valid ? "" : " \xB7 invalid"}`,
+    `  dir: ${plugin.dir}`,
+    m.description ? `  description: ${m.description}` : void 0,
+    `  assets: ${m.skills.length} skill(s), ${m.commands.length} command(s), ${m.agents.length} agent(s), ${Object.keys(m.mcpServers).length} MCP server(s), ${Object.keys(m.hooks?.events ?? {}).length} hook event(s)`,
+    m.permissionHints.length ? `  permission hints: ${m.permissionHints.join("; ")}` : void 0,
+    plugin.error ? `  error: ${plugin.error}` : void 0
+  ].filter((line) => Boolean(line));
+}
+
+// src/tools/hooks.ts
+import { execSync } from "child_process";
+import { createHash as createHash2 } from "crypto";
+import { existsSync as existsSync3, mkdirSync as mkdirSync3, readFileSync as readFileSync3 } from "fs";
+import { join as join3 } from "path";
+var TRUST_FILE = "hooks-trust.json";
+var DEFAULT_TIMEOUT_MS = 5e3;
+function asArray(entry) {
+  if (!entry) return [];
+  const raw = Array.isArray(entry) ? entry : [entry];
+  return raw.map((item) => typeof item === "string" ? { command: item } : item);
+}
+function hookTrustPath(configDir) {
+  return join3(configDir, TRUST_FILE);
+}
+function loadHookTrustStore(configDir) {
+  const file = hookTrustPath(configDir);
+  if (!existsSync3(file)) return { records: [] };
+  try {
+    const parsed = JSON.parse(readFileSync3(file, "utf-8"));
+    return { records: Array.isArray(parsed.records) ? parsed.records : [] };
+  } catch {
+    return { records: [] };
+  }
+}
+function saveHookTrustStore(configDir, store) {
+  mkdirSync3(configDir, { recursive: true });
+  atomicWriteFileSync(hookTrustPath(configDir), JSON.stringify(store, null, 2));
+}
+function hashHook(event, command) {
+  return createHash2("sha256").update(`${event}
+${command}`, "utf-8").digest("hex");
+}
+function isTrusted(source, event, hash, store) {
+  if (source === "user" || source === "managed") return true;
+  return store.records.some((r) => r.source === source && r.event === event && r.hash === hash);
+}
+function listHooks(config, configDir) {
+  if (!config || config.enabled === false) return [];
+  const store = loadHookTrustStore(configDir);
+  const out = [];
+  const push = (event, hook, index) => {
+    if (!hook.command) return;
+    const source = hook.source ?? "user";
+    const hash = hashHook(event, hook.command);
+    out.push({
+      id: `${event}:${index}`,
+      event,
+      command: hook.command,
+      source,
+      hash,
+      trusted: isTrusted(source, event, hash, store),
+      disabled: hook.disabled === true,
+      description: hook.description
+    });
+  };
+  if (config.preToolExecution) push("PreToolUse", { command: config.preToolExecution }, 0);
+  if (config.postToolExecution) push("PostToolUse", { command: config.postToolExecution }, 0);
+  for (const [event, entry] of Object.entries(config.events ?? {})) {
+    asArray(entry).forEach((hook, i) => push(event, hook, i));
+  }
+  return out;
+}
+function trustHook(configDir, hook) {
+  const store = loadHookTrustStore(configDir);
+  const next = store.records.filter((r) => !(r.source === hook.source && r.event === hook.event && r.id === hook.id));
+  next.push({ id: hook.id, event: hook.event, source: hook.source, hash: hook.hash, trustedAt: (/* @__PURE__ */ new Date()).toISOString() });
+  saveHookTrustStore(configDir, { records: next });
+}
+function untrustHook(configDir, hook) {
+  const store = loadHookTrustStore(configDir);
+  saveHookTrustStore(configDir, {
+    records: store.records.filter((r) => !(r.source === hook.source && r.event === hook.event && r.hash === hook.hash))
+  });
+}
+function getPendingHookTrust(config, configDir) {
+  return listHooks(config, configDir).filter((h) => h.source === "project" && !h.disabled && !h.trusted);
+}
+function normalizeDecision(value, hook) {
+  if (!value || typeof value !== "object") return null;
+  const obj = value;
+  const action = obj.action;
+  if (action !== "allow" && action !== "deny" && action !== "ask") return null;
+  return {
+    action,
+    reason: typeof obj.reason === "string" ? obj.reason : void 0,
+    prompt: typeof obj.prompt === "string" ? obj.prompt : void 0,
+    contextAppend: typeof obj.contextAppend === "string" ? obj.contextAppend : void 0,
+    warning: typeof obj.warning === "string" ? obj.warning : void 0,
+    warnings: Array.isArray(obj.warnings) ? obj.warnings.filter((x) => typeof x === "string") : void 0,
+    hook
+  };
+}
+function runStructuredHook(hook, descriptor, payload) {
+  if (hook.disabled === true) return null;
+  const timeout = Math.max(100, Math.min(hook.timeoutMs ?? DEFAULT_TIMEOUT_MS, 3e4));
+  try {
+    const stdout = execSync(hook.command, {
+      timeout,
+      stdio: ["pipe", "pipe", "pipe"],
+      encoding: "utf-8",
+      env: {
+        ...process.env,
+        AICLI_HOOK_EVENT: payload.event,
+        AICLI_HOOK_EVENT_JSON: JSON.stringify(payload)
+      }
+    }).trim();
+    if (!stdout) return null;
+    return normalizeDecision(JSON.parse(stdout), descriptor);
+  } catch (err) {
+    process.stderr.write(`\u26A0 Hook failed: ${hook.command.slice(0, 100)}
+`);
+    if (hook.required) {
+      return { action: "deny", reason: err instanceof Error ? err.message : String(err), hook: descriptor };
+    }
+    return null;
+  }
+}
+function runLifecycleHooks(config, event, payload, opts) {
+  if (!config || config.enabled === false) return [];
+  const options = typeof opts === "string" ? { configDir: opts } : opts;
+  const store = loadHookTrustStore(options.configDir);
+  const hooks = asArray(config.events?.[event]);
+  const decisions = [];
+  for (let i = 0; i < hooks.length; i++) {
+    const hook = hooks[i];
+    if (!hook.command || hook.disabled) continue;
+    const source = hook.source ?? "user";
+    const hash = hashHook(event, hook.command);
+    const descriptor = {
+      id: `${event}:${i}`,
+      event,
+      command: hook.command,
+      source,
+      hash,
+      trusted: isTrusted(source, event, hash, store),
+      disabled: false,
+      description: hook.description
+    };
+    if (!descriptor.trusted) {
+      options.onSummary?.(`hook skipped: ${event} project hook requires trust (${hash.slice(0, 12)})`);
+      continue;
+    }
+    const decision = runStructuredHook(hook, descriptor, { event, ...payload });
+    if (decision) {
+      decisions.push(decision);
+      options.onSummary?.(`hook ${event}: ${decision.action}${decision.reason ? ` (${decision.reason})` : ""}`);
+    }
+  }
+  return decisions;
+}
+function rewriteTemplate(template, isWindows) {
+  const ref = (name) => isWindows ? `%${name}%` : `$${name}`;
+  return template.replace(/\{tool\}/g, ref("AICLI_HOOK_TOOL")).replace(/\{dangerLevel\}/g, ref("AICLI_HOOK_DANGER_LEVEL")).replace(/\{args\}/g, ref("AICLI_HOOK_ARGS")).replace(/\{status\}/g, ref("AICLI_HOOK_STATUS"));
+}
+function runHook(template, vars) {
+  if (!template) return;
+  const isWindows = process.platform === "win32";
+  const cmd = rewriteTemplate(template, isWindows);
+  try {
+    execSync(cmd, {
+      timeout: DEFAULT_TIMEOUT_MS,
+      stdio: ["pipe", "pipe", "pipe"],
+      encoding: "utf-8",
+      env: {
+        ...process.env,
+        AICLI_HOOK_TOOL: vars.tool,
+        AICLI_HOOK_DANGER_LEVEL: vars.dangerLevel ?? "",
+        AICLI_HOOK_ARGS: vars.args ?? "",
+        AICLI_HOOK_STATUS: vars.status ?? ""
+      }
+    });
+  } catch {
+    process.stderr.write(`\u26A0 Hook failed: ${cmd.slice(0, 100)}
+`);
+  }
+}
+
+export {
+  runTool,
+  getStatsSnapshot,
+  getTopFailingTools,
+  getTopUsedTools,
+  resetStats,
+  installFlushOnExit,
+  listHooks,
+  trustHook,
+  untrustHook,
+  getPendingHookTrust,
+  runLifecycleHooks,
+  runHook,
+  pluginRoot,
+  installPlugin,
+  setPluginEnabled,
+  trustPlugin,
+  getInstalledPlugin,
+  listInstalledPlugins,
+  mergePluginHooks,
+  getActivePluginAssets,
+  describePlugin
+};

package/dist/{chunk-WKOQ5CYC.js → chunk-KIEZBTVD.js}

@@ -8,7 +8,7 @@ import {
   CONFIG_FILE_NAME,
   HISTORY_DIR_NAME,
   PLUGINS_DIR_NAME
-} from "./chunk-XJGEQIYS.js";
+} from "./chunk-U7KVU25H.js";
 import {
   atomicWriteFileSync
 } from "./chunk-IW3Q7AE5.js";