@difflab/pi 0.1.0-rc.202609140747.4d45e72.2

package/dist/index.js

@@ -0,0 +1,510 @@
+// src/mcp.ts
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+var mcp = {
+  globalConfigPath(homeDir = homedir()) {
+    return join(homeDir, ".config", "mcp", "mcp.json");
+  },
+  async serversEnsure(servers, options = {}) {
+    const path = options.path ?? mcp.globalConfigPath();
+    const currentText = await readOptional(path);
+    const current = parseConfig(currentText, path);
+    const nextServers = { ...current.mcpServers };
+    for (const [name, entry] of Object.entries(servers)) {
+      nextServers[name] = mergeEntry(nextServers[name], entry);
+    }
+    const next = { ...current, mcpServers: nextServers };
+    const changed = JSON.stringify(current) !== JSON.stringify(next);
+    if (changed && !options.dryRun) {
+      await mkdir(dirname(path), { recursive: true });
+      await writeFile(path, `${JSON.stringify(next, null, 2)}
+`, "utf8");
+    }
+    return { path, changed, existed: currentText !== undefined, planned: changed && options.dryRun === true };
+  }
+};
+function mergeEntry(current, required) {
+  const merged = { ...current, ...required };
+  if (current?.env || required.env)
+    merged.env = { ...current?.env, ...required.env };
+  return merged;
+}
+function parseConfig(content, path) {
+  if (!content?.trim())
+    return { mcpServers: {} };
+  try {
+    const value = JSON.parse(content);
+    if (!isRecord(value))
+      throw new Error("not an object");
+    const servers = value.mcpServers;
+    if (servers !== undefined && !isRecord(servers))
+      throw new Error("mcpServers is not an object");
+    return { ...value, mcpServers: servers ?? {} };
+  } catch {
+    throw new Error(`Expected a valid pi-mcp-adapter configuration in ${path}.`);
+  }
+}
+async function readOptional(path) {
+  try {
+    return await readFile(path, "utf8");
+  } catch (error) {
+    if (error instanceof Error && "code" in error && error.code === "ENOENT")
+      return;
+    throw error;
+  }
+}
+function isRecord(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+// src/mise.ts
+import { mkdir as mkdir2, readFile as readFile2, writeFile as writeFile2 } from "node:fs/promises";
+import { homedir as homedir2 } from "node:os";
+import { basename, dirname as dirname2, join as join3 } from "node:path";
+
+// src/process.ts
+import { constants } from "node:fs";
+import { access } from "node:fs/promises";
+import { delimiter, join as join2 } from "node:path";
+import { spawn } from "node:child_process";
+async function findExecutable(name) {
+  if (name.includes("/")) {
+    try {
+      await access(name, constants.X_OK);
+      return name;
+    } catch {
+      return;
+    }
+  }
+  for (const directory of (process.env.PATH ?? "").split(delimiter)) {
+    if (!directory)
+      continue;
+    const candidate = join2(directory, name);
+    try {
+      await access(candidate, constants.X_OK);
+      return candidate;
+    } catch {}
+  }
+  return;
+}
+function run(command, args, options = {}) {
+  return new Promise((resolve, reject) => {
+    const child = spawn(command, args, {
+      cwd: options.cwd,
+      env: options.env ?? process.env,
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    let stdout = "";
+    let stderr = "";
+    child.stdout.on("data", (chunk) => {
+      stdout = appendBounded(stdout, chunk.toString());
+    });
+    child.stderr.on("data", (chunk) => {
+      stderr = appendBounded(stderr, chunk.toString());
+    });
+    child.on("error", reject);
+    child.on("close", (code) => resolve({ code: code ?? 1, stdout, stderr }));
+  });
+}
+async function runChecked(command, args, options = {}) {
+  const result = await run(command, args, options);
+  if (result.code === 0)
+    return result;
+  const detail = result.stderr.trim() || result.stdout.trim() || `exit code ${result.code}`;
+  throw new Error(`${command} ${args.join(" ")} failed: ${detail}`);
+}
+function appendBounded(current, next) {
+  const combined = current + next;
+  return combined.length <= 65536 ? combined : combined.slice(-65536);
+}
+
+// src/mise.ts
+var mise = {
+  async executableCheck(name = "mise") {
+    return findExecutable(name);
+  },
+  async install(options = {}) {
+    const homeDir = options.homeDir ?? homedir2();
+    const platform = options.platform ?? process.platform;
+    if (platform === "win32")
+      throw new Error("Automatic mise installation supports macOS and Linux only.");
+    const installedPath = join3(homeDir, ".local", "bin", "mise");
+    if (options.dryRun)
+      return installedPath;
+    await runChecked("sh", ["-c", "curl -fsSL https://mise.run | sh"]);
+    const executable = await findExecutable(installedPath) ?? await findExecutable("mise");
+    if (!executable)
+      throw new Error(`mise installation completed, but ${installedPath} was not found.`);
+    return executable;
+  },
+  async hookEnsure(executable, options = {}) {
+    const homeDir = options.homeDir ?? homedir2();
+    const hook = shellHook(basename(options.shell ?? process.env.SHELL ?? ""), executable, homeDir);
+    const current = await readOptional2(hook.path);
+    if (current.includes(MISE_HOOK_START))
+      return { path: hook.path, changed: false, planned: false };
+    if (options.dryRun)
+      return { path: hook.path, changed: true, planned: true };
+    const separator = current.length === 0 || current.endsWith(`
+`) ? "" : `
+`;
+    await mkdir2(dirname2(hook.path), { recursive: true });
+    await writeFile2(hook.path, `${current}${separator}${hook.content}`, "utf8");
+    return { path: hook.path, changed: true, planned: false };
+  },
+  async toolCheckGlobal(executable, tool, minimumMajor = 0) {
+    const result = await run(executable, ["ls", "--global", "--installed", tool, "--json"]);
+    return result.code === 0 && hasInstalledTool(result.stdout, minimumMajor);
+  },
+  async toolInstallGlobal(executable, specification) {
+    await runChecked(executable, ["use", "--global", specification]);
+  },
+  async toolCheckLocal(executable, tool, cwd = process.cwd()) {
+    const result = await run(executable, ["ls", "--local", "--installed", tool, "--json"], { cwd });
+    return result.code === 0 && hasInstalledTool(result.stdout);
+  },
+  async toolInstallLocal(executable, specification, cwd = process.cwd()) {
+    await runChecked(executable, ["use", "--path", cwd, specification], { cwd });
+  },
+  async toolUpdateAllGlobal(executable, homeDir = homedir2()) {
+    await runChecked(executable, ["upgrade"], { cwd: homeDir });
+  }
+};
+var MISE_HOOK_START = "# >>> @difflab/pi mise >>>";
+var MISE_HOOK_END = "# <<< @difflab/pi mise <<<";
+function shellHook(shell, executable, homeDir) {
+  const command = shellQuote(executable);
+  if (shell === "bash") {
+    return {
+      path: join3(homeDir, ".bashrc"),
+      content: `${MISE_HOOK_START}
+eval "$(${command} activate bash)"
+${MISE_HOOK_END}
+`
+    };
+  }
+  if (shell === "zsh") {
+    return {
+      path: join3(homeDir, ".zshrc"),
+      content: `${MISE_HOOK_START}
+eval "$(${command} activate zsh)"
+${MISE_HOOK_END}
+`
+    };
+  }
+  if (shell === "fish") {
+    return {
+      path: join3(homeDir, ".config", "fish", "config.fish"),
+      content: `${MISE_HOOK_START}
+${command} activate fish | source
+${MISE_HOOK_END}
+`
+    };
+  }
+  throw new Error(`Unsupported shell "${shell || "unknown"}". Supported shells: bash, zsh, fish.`);
+}
+function hasInstalledTool(output, minimumMajor = 0) {
+  try {
+    const value = JSON.parse(output);
+    if (!Array.isArray(value))
+      return false;
+    return value.some((entry) => {
+      if (!entry || typeof entry !== "object" || !("installed" in entry) || entry.installed !== true)
+        return false;
+      if (minimumMajor === 0)
+        return true;
+      if (!("version" in entry) || typeof entry.version !== "string")
+        return false;
+      return Number.parseInt(entry.version, 10) >= minimumMajor;
+    });
+  } catch {
+    return false;
+  }
+}
+async function readOptional2(path) {
+  try {
+    return await readFile2(path, "utf8");
+  } catch (error) {
+    if (error instanceof Error && "code" in error && error.code === "ENOENT")
+      return "";
+    throw error;
+  }
+}
+function shellQuote(value) {
+  return `'${value.replaceAll("'", "'\\''")}'`;
+}
+// src/pi.ts
+import { mkdir as mkdir3, readFile as readFile3, writeFile as writeFile3 } from "node:fs/promises";
+import { homedir as homedir3 } from "node:os";
+import { dirname as dirname3, join as join4 } from "node:path";
+var pi = {
+  async executableCheck() {
+    return findExecutable("pi");
+  },
+  async packageList(executable) {
+    return (await runChecked(executable, ["list"])).stdout;
+  },
+  packageCheck(listOutput, source) {
+    if (listOutput.includes(source))
+      return true;
+    return source.startsWith("https://") && listOutput.includes(source.slice("https://".length));
+  },
+  async packageInstall(executable, source) {
+    await runChecked(executable, ["install", source]);
+  },
+  agentDir(homeDir = homedir3()) {
+    return resolveAgentDir(homeDir);
+  },
+  async skillCheckGlobal(name, agentDir = resolveAgentDir(), sharedSkillsDir = join4(homedir3(), ".agents", "skills")) {
+    const roots = [join4(agentDir, "skills"), sharedSkillsDir];
+    for (const root of roots) {
+      if (await readOptional3(join4(root, name, "SKILL.md")) !== undefined)
+        return true;
+    }
+    return false;
+  },
+  async skillInstallGlobal(miseExecutable, source, names) {
+    const selection = names.flatMap((name) => ["--skill", name]);
+    await runChecked(miseExecutable, [
+      "x",
+      "node@22",
+      "--",
+      "npx",
+      "-y",
+      "skills",
+      "add",
+      source,
+      ...selection,
+      "--global",
+      "--agent",
+      "pi",
+      "--yes"
+    ]);
+  },
+  async configEnsure(path, update, dryRun = false) {
+    const currentText = await readOptional3(path);
+    const current = parseObject(currentText, path);
+    const next = update(current);
+    const changed = JSON.stringify(current) !== JSON.stringify(next);
+    if (changed && !dryRun) {
+      await mkdir3(dirname3(path), { recursive: true });
+      await writeFile3(path, `${JSON.stringify(next, null, 2)}
+`, "utf8");
+    }
+    return { path, changed, existed: currentText !== undefined, planned: changed && dryRun };
+  }
+};
+function resolveAgentDir(homeDir = homedir3()) {
+  return process.env.PI_CODING_AGENT_DIR ?? (process.env.XDG_CONFIG_HOME ? join4(process.env.XDG_CONFIG_HOME, "pi") : join4(homeDir, ".pi", "agent"));
+}
+async function readOptional3(path) {
+  try {
+    return await readFile3(path, "utf8");
+  } catch (error) {
+    if (error instanceof Error && "code" in error && error.code === "ENOENT")
+      return;
+    throw error;
+  }
+}
+function parseObject(content, path) {
+  if (!content?.trim())
+    return {};
+  try {
+    const value = JSON.parse(content);
+    if (value && typeof value === "object" && !Array.isArray(value))
+      return value;
+  } catch {}
+  throw new Error(`Expected valid JSON object in ${path}.`);
+}
+// src/setup.ts
+import { homedir as homedir4 } from "node:os";
+import { join as join5 } from "node:path";
+async function ensureMise(options = {}) {
+  const homeDir = options.homeDir ?? homedir4();
+  const current = await mise.executableCheck() ?? await mise.executableCheck(join5(homeDir, ".local", "bin", "mise"));
+  if (current)
+    return { executable: current, action: action("mise", "ready", current) };
+  progress(options, "Installing mise");
+  const executable = await mise.install({
+    dryRun: options.dryRun,
+    homeDir: options.homeDir,
+    platform: options.platform
+  });
+  return { executable, action: action("mise", options.dryRun ? "planned" : "installed", executable) };
+}
+async function ensureMiseHooks(miseExecutable, options = {}) {
+  if (options.installMiseHook === false)
+    return action("mise shell hook", "skipped", "disabled");
+  const result = await mise.hookEnsure(miseExecutable, {
+    dryRun: options.dryRun,
+    homeDir: options.homeDir,
+    shell: options.shell
+  });
+  if (!result.changed)
+    return action("mise shell hook", "ready", result.path);
+  return action("mise shell hook", result.planned ? "planned" : "installed", result.path);
+}
+async function ensureMiseDeps(miseExecutable, options = {}) {
+  const canRunMise = Boolean(await mise.executableCheck(miseExecutable));
+  const actions = [];
+  for (const dependency of MISE_DEPENDENCIES) {
+    const installed = canRunMise && await mise.toolCheckGlobal(miseExecutable, dependency.tool, dependency.minimumMajor);
+    if (installed) {
+      actions.push(action(dependency.name, "ready", dependency.spec));
+      continue;
+    }
+    progress(options, `Installing ${dependency.name} with mise`);
+    if (!options.dryRun)
+      await mise.toolInstallGlobal(miseExecutable, dependency.spec);
+    actions.push(action(dependency.name, options.dryRun ? "planned" : "installed", dependency.spec));
+  }
+  return actions;
+}
+async function ensurePiPlugins(options = {}) {
+  const actions = await ensurePiPackages(PI_PACKAGES, options);
+  const agentDir = options.agentDir ?? pi.agentDir(options.homeDir);
+  const webSearch = await pi.configEnsure(join5(agentDir, "web-search.json"), (config) => ({ ...config, workflow: "auto-summary" }), options.dryRun);
+  actions.push(configAction("web search settings", webSearch));
+  const lsp = await pi.configEnsure(join5(agentDir, "pi-lsp.json"), (config) => ({
+    ...config,
+    progressive: { ...record(config.progressive), enabled: true, inject: "none" }
+  }), options.dryRun);
+  actions.push(configAction("pi-lsp settings", lsp));
+  return actions;
+}
+async function ensurePiSkills(miseExecutable, options = {}) {
+  const agentDir = options.agentDir ?? pi.agentDir(options.homeDir);
+  const sharedSkillsDir = join5(options.homeDir ?? homedir4(), ".agents", "skills");
+  const actions = [];
+  for (const source of PI_SKILL_SOURCES) {
+    const missing = [];
+    for (const name of source.skills) {
+      if (await pi.skillCheckGlobal(name, agentDir, sharedSkillsDir))
+        actions.push(action(`pi skill ${name}`, "ready", source.repository));
+      else
+        missing.push(name);
+    }
+    if (missing.length === 0)
+      continue;
+    progress(options, `Installing skills from ${source.repository}`);
+    if (!options.dryRun)
+      await pi.skillInstallGlobal(miseExecutable, source.repository, missing);
+    for (const name of missing) {
+      actions.push(action(`pi skill ${name}`, options.dryRun ? "planned" : "installed", source.repository));
+    }
+  }
+  return actions;
+}
+async function ensureMcpAdapters(miseExecutable, options = {}) {
+  const actions = await ensurePiPackages([MCP_ADAPTER_PACKAGE], options);
+  const projectDir = options.projectDir ?? process.cwd();
+  const servers = {
+    "docs-mcp-server": {
+      command: miseExecutable,
+      args: ["x", "node@22", "--", "npx", "-y", "@arabold/docs-mcp-server@latest"]
+    },
+    mise: {
+      command: miseExecutable,
+      args: ["--cd", projectDir, "mcp"],
+      env: { MISE_EXPERIMENTAL: "1" }
+    },
+    "context-mode": {
+      command: miseExecutable,
+      args: ["x", "npm:context-mode@latest", "--", "context-mode"]
+    }
+  };
+  if (options.issueTracker === "linear") {
+    servers.linear = { url: "https://mcp.linear.app/mcp", auth: "oauth", protocolVersion: "auto" };
+  } else if (options.issueTracker === "jira") {
+    servers.atlassian = { url: "https://mcp.atlassian.com/v1/mcp", auth: "oauth", protocolVersion: "auto" };
+  }
+  const result = await mcp.serversEnsure(servers, {
+    dryRun: options.dryRun,
+    path: mcp.globalConfigPath(options.homeDir)
+  });
+  actions.push(configAction("MCP configuration", result));
+  return actions;
+}
+async function setupPi(options = {}) {
+  const miseResult = await ensureMise(options);
+  const actions = [miseResult.action];
+  actions.push(await ensureMiseHooks(miseResult.executable, options));
+  actions.push(...await ensureMiseDeps(miseResult.executable, options));
+  actions.push(...await ensurePiPlugins(options));
+  actions.push(...await ensurePiSkills(miseResult.executable, options));
+  actions.push(...await ensureMcpAdapters(miseResult.executable, options));
+  return {
+    actions,
+    restartPi: actions.some((item) => (item.status === "installed" || item.status === "updated") && (item.name.startsWith("pi package ") || item.name.startsWith("pi skill ") || item.name === "MCP configuration" || item.name === "web search settings" || item.name === "pi-lsp settings"))
+  };
+}
+var MISE_DEPENDENCIES = [
+  { name: "node", tool: "node", spec: "node@22", minimumMajor: 22 },
+  { name: "zellij", tool: "zellij", spec: "zellij@latest", minimumMajor: 0 },
+  { name: "helix", tool: "helix", spec: "helix@latest", minimumMajor: 0 },
+  { name: "tuicr", tool: "github:agavra/tuicr", spec: "github:agavra/tuicr@latest", minimumMajor: 0 },
+  { name: "context-mode", tool: "npm:context-mode", spec: "npm:context-mode@latest", minimumMajor: 0 }
+];
+var PI_PACKAGES = [
+  "npm:@tintinweb/pi-subagents",
+  "npm:pi-schedule-prompt",
+  "npm:@narumitw/pi-btw",
+  "npm:pi-web-access",
+  "npm:@gitawego/pi-lsp",
+  "npm:@juicesharp/rpiv-ask-user-question",
+  "npm:context-mode"
+];
+var PI_SKILL_SOURCES = [
+  { repository: "arabold/docs-mcp-server", skills: ["docs-manage", "docs-search", "fetch-url"] },
+  { repository: "AminBlg/SimpleEnglish", skills: ["simple-english"] }
+];
+var MCP_ADAPTER_PACKAGE = "npm:pi-mcp-adapter";
+async function ensurePiPackages(packages, options) {
+  const executable = await pi.executableCheck();
+  if (!executable && !options.dryRun)
+    throw new Error("Install pi before you run diffpi_setup.");
+  let installed = executable ? await pi.packageList(executable) : "";
+  const actions = [];
+  for (const source of packages) {
+    if (pi.packageCheck(installed, source)) {
+      actions.push(action(`pi package ${source}`, "ready", source));
+      continue;
+    }
+    progress(options, `Installing pi package ${source}`);
+    if (!options.dryRun) {
+      await pi.packageInstall(executable, source);
+      installed += `
+${source}`;
+    }
+    actions.push(action(`pi package ${source}`, options.dryRun ? "planned" : "installed", source));
+  }
+  return actions;
+}
+function configAction(name, result) {
+  if (!result.changed)
+    return action(name, "ready", result.path);
+  if (result.planned)
+    return action(name, "planned", result.path);
+  return action(name, result.existed ? "updated" : "installed", result.path);
+}
+function action(name, status, detail) {
+  return { name, status, detail };
+}
+function progress(options, message) {
+  options.onProgress?.(message);
+}
+function record(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value) ? value : {};
+}
+export {
+  ensureMcpAdapters,
+  ensureMise,
+  ensureMiseDeps,
+  ensureMiseHooks,
+  ensurePiPlugins,
+  ensurePiSkills,
+  mcp,
+  mise,
+  pi,
+  setupPi
+};

package/dist/mcp.d.ts

@@ -0,0 +1,16 @@
+import type { ServerEntry } from 'pi-mcp-adapter/types';
+export interface McpEnsureOptions {
+    dryRun?: boolean;
+    path?: string;
+}
+export interface McpEnsureResult {
+    path: string;
+    changed: boolean;
+    existed: boolean;
+    planned: boolean;
+}
+export declare const mcp: {
+    globalConfigPath(homeDir?: string): string;
+    serversEnsure(servers: Readonly<Record<string, ServerEntry>>, options?: McpEnsureOptions): Promise<McpEnsureResult>;
+};
+//# sourceMappingURL=mcp.d.ts.map

package/dist/mcp.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mcp.d.ts","sourceRoot":"","sources":["../src/mcp.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAa,WAAW,EAAE,MAAM,sBAAsB,CAAC;AAEnE,MAAM,WAAW,gBAAgB;IAC/B,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,IAAI,CAAC,EAAE,MAAM,CAAC;CACf;AAED,MAAM,WAAW,eAAe;IAC9B,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,OAAO,CAAC;IACjB,OAAO,EAAE,OAAO,CAAC;IACjB,OAAO,EAAE,OAAO,CAAC;CAClB;AAED,eAAO,MAAM,GAAG;wCACyB,MAAM;2BAKlC,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,WAAW,CAAC,CAAC,YACrC,gBAAgB,GACxB,OAAO,CAAC,eAAe,CAAC;CAmB5B,CAAC"}

package/dist/mise.d.ts

@@ -0,0 +1,26 @@
+export interface MiseInstallOptions {
+    dryRun?: boolean;
+    homeDir?: string;
+    platform?: NodeJS.Platform;
+}
+export interface MiseHookOptions {
+    dryRun?: boolean;
+    homeDir?: string;
+    shell?: string;
+}
+export interface MiseHookResult {
+    path: string;
+    changed: boolean;
+    planned: boolean;
+}
+export declare const mise: {
+    executableCheck(name?: string): Promise<string | undefined>;
+    install(options?: MiseInstallOptions): Promise<string>;
+    hookEnsure(executable: string, options?: MiseHookOptions): Promise<MiseHookResult>;
+    toolCheckGlobal(executable: string, tool: string, minimumMajor?: number): Promise<boolean>;
+    toolInstallGlobal(executable: string, specification: string): Promise<void>;
+    toolCheckLocal(executable: string, tool: string, cwd?: string): Promise<boolean>;
+    toolInstallLocal(executable: string, specification: string, cwd?: string): Promise<void>;
+    toolUpdateAllGlobal(executable: string, homeDir?: string): Promise<void>;
+};
+//# sourceMappingURL=mise.d.ts.map

package/dist/mise.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mise.d.ts","sourceRoot":"","sources":["../src/mise.ts"],"names":[],"mappings":"AAKA,MAAM,WAAW,kBAAkB;IACjC,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,QAAQ,CAAC,EAAE,MAAM,CAAC,QAAQ,CAAC;CAC5B;AAED,MAAM,WAAW,eAAe;IAC9B,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,WAAW,cAAc;IAC7B,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,OAAO,CAAC;IACjB,OAAO,EAAE,OAAO,CAAC;CAClB;AAED,eAAO,MAAM,IAAI;oCACuB,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC;sBAI1C,kBAAkB,GAAQ,OAAO,CAAC,MAAM,CAAC;2BAcnC,MAAM,YAAW,eAAe,GAAQ,OAAO,CAAC,cAAc,CAAC;gCAc1D,MAAM,QAAQ,MAAM,0BAAqB,OAAO,CAAC,OAAO,CAAC;kCAKvD,MAAM,iBAAiB,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;+BAIhD,MAAM,QAAQ,MAAM,iBAAwB,OAAO,CAAC,OAAO,CAAC;iCAK1D,MAAM,iBAAiB,MAAM,iBAAwB,OAAO,CAAC,IAAI,CAAC;oCAI/D,MAAM,qBAAwB,OAAO,CAAC,IAAI,CAAC;CAGlF,CAAC"}

package/dist/pi.d.ts

@@ -0,0 +1,19 @@
+type JsonObject = Record<string, unknown>;
+export interface PiConfigResult {
+    path: string;
+    changed: boolean;
+    existed: boolean;
+    planned: boolean;
+}
+export declare const pi: {
+    executableCheck(): Promise<string | undefined>;
+    packageList(executable: string): Promise<string>;
+    packageCheck(listOutput: string, source: string): boolean;
+    packageInstall(executable: string, source: string): Promise<void>;
+    agentDir(homeDir?: string): string;
+    skillCheckGlobal(name: string, agentDir?: string, sharedSkillsDir?: string): Promise<boolean>;
+    skillInstallGlobal(miseExecutable: string, source: string, names: readonly string[]): Promise<void>;
+    configEnsure(path: string, update: (config: JsonObject) => JsonObject, dryRun?: boolean): Promise<PiConfigResult>;
+};
+export {};
+//# sourceMappingURL=pi.d.ts.map

package/dist/pi.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pi.d.ts","sourceRoot":"","sources":["../src/pi.ts"],"names":[],"mappings":"AAKA,KAAK,UAAU,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;AAE1C,MAAM,WAAW,cAAc;IAC7B,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,OAAO,CAAC;IACjB,OAAO,EAAE,OAAO,CAAC;IACjB,OAAO,EAAE,OAAO,CAAC;CAClB;AAED,eAAO,MAAM,EAAE;uBACY,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC;4BAItB,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;6BAI7B,MAAM,UAAU,MAAM,GAAG,OAAO;+BAKxB,MAAM,UAAU,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;gCAIxC,MAAM;2BAK7B,MAAM,gDAGX,OAAO,CAAC,OAAO,CAAC;uCAWsB,MAAM,UAAU,MAAM,SAAS,SAAS,MAAM,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC;uBAoBjG,MAAM,UACJ,CAAC,MAAM,EAAE,UAAU,KAAK,UAAU,qBAEzC,OAAO,CAAC,cAAc,CAAC;CAa3B,CAAC"}

package/dist/process.d.ts

@@ -0,0 +1,13 @@
+export interface CommandResult {
+    code: number;
+    stdout: string;
+    stderr: string;
+}
+export interface CommandOptions {
+    cwd?: string;
+    env?: NodeJS.ProcessEnv;
+}
+export declare function findExecutable(name: string): Promise<string | undefined>;
+export declare function run(command: string, args: string[], options?: CommandOptions): Promise<CommandResult>;
+export declare function runChecked(command: string, args: string[], options?: CommandOptions): Promise<CommandResult>;
+//# sourceMappingURL=process.d.ts.map

package/dist/process.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"process.d.ts","sourceRoot":"","sources":["../src/process.ts"],"names":[],"mappings":"AAKA,MAAM,WAAW,aAAa;IAC5B,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,WAAW,cAAc;IAC7B,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,GAAG,CAAC,EAAE,MAAM,CAAC,UAAU,CAAC;CACzB;AAED,wBAAsB,cAAc,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC,CAsB9E;AAED,wBAAgB,GAAG,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,EAAE,OAAO,GAAE,cAAmB,GAAG,OAAO,CAAC,aAAa,CAAC,CAmBzG;AAED,wBAAsB,UAAU,CAC9B,OAAO,EAAE,MAAM,EACf,IAAI,EAAE,MAAM,EAAE,EACd,OAAO,GAAE,cAAmB,GAC3B,OAAO,CAAC,aAAa,CAAC,CAMxB"}

package/dist/setup.d.ts

@@ -0,0 +1,33 @@
+export type IssueTracker = 'none' | 'linear' | 'jira';
+export type SetupStatus = 'ready' | 'installed' | 'updated' | 'skipped' | 'planned';
+export interface SetupAction {
+    name: string;
+    status: SetupStatus;
+    detail: string;
+}
+export interface SetupOptions {
+    issueTracker?: IssueTracker;
+    installMiseHook?: boolean;
+    dryRun?: boolean;
+    homeDir?: string;
+    agentDir?: string;
+    shell?: string;
+    platform?: NodeJS.Platform;
+    projectDir?: string;
+    onProgress?: (message: string) => void;
+}
+export interface SetupResult {
+    actions: SetupAction[];
+    restartPi: boolean;
+}
+export declare function ensureMise(options?: SetupOptions): Promise<{
+    executable: string;
+    action: SetupAction;
+}>;
+export declare function ensureMiseHooks(miseExecutable: string, options?: SetupOptions): Promise<SetupAction>;
+export declare function ensureMiseDeps(miseExecutable: string, options?: SetupOptions): Promise<SetupAction[]>;
+export declare function ensurePiPlugins(options?: SetupOptions): Promise<SetupAction[]>;
+export declare function ensurePiSkills(miseExecutable: string, options?: SetupOptions): Promise<SetupAction[]>;
+export declare function ensureMcpAdapters(miseExecutable: string, options?: SetupOptions): Promise<SetupAction[]>;
+export declare function setupPi(options?: SetupOptions): Promise<SetupResult>;
+//# sourceMappingURL=setup.d.ts.map

package/dist/setup.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"setup.d.ts","sourceRoot":"","sources":["../src/setup.ts"],"names":[],"mappings":"AAOA,MAAM,MAAM,YAAY,GAAG,MAAM,GAAG,QAAQ,GAAG,MAAM,CAAC;AACtD,MAAM,MAAM,WAAW,GAAG,OAAO,GAAG,WAAW,GAAG,SAAS,GAAG,SAAS,GAAG,SAAS,CAAC;AAEpF,MAAM,WAAW,WAAW;IAC1B,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,WAAW,CAAC;IACpB,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,WAAW,YAAY;IAC3B,YAAY,CAAC,EAAE,YAAY,CAAC;IAC5B,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,QAAQ,CAAC,EAAE,MAAM,CAAC,QAAQ,CAAC;IAC3B,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,UAAU,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,CAAC;CACxC;AAED,MAAM,WAAW,WAAW;IAC1B,OAAO,EAAE,WAAW,EAAE,CAAC;IACvB,SAAS,EAAE,OAAO,CAAC;CACpB;AAED,wBAAsB,UAAU,CAAC,OAAO,GAAE,YAAiB,GAAG,OAAO,CAAC;IAAE,UAAU,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,WAAW,CAAA;CAAE,CAAC,CAajH;AAED,wBAAsB,eAAe,CAAC,cAAc,EAAE,MAAM,EAAE,OAAO,GAAE,YAAiB,GAAG,OAAO,CAAC,WAAW,CAAC,CAU9G;AAED,wBAAsB,cAAc,CAAC,cAAc,EAAE,MAAM,EAAE,OAAO,GAAE,YAAiB,GAAG,OAAO,CAAC,WAAW,EAAE,CAAC,CAkB/G;AAED,wBAAsB,eAAe,CAAC,OAAO,GAAE,YAAiB,GAAG,OAAO,CAAC,WAAW,EAAE,CAAC,CAqBxF;AAED,wBAAsB,cAAc,CAAC,cAAc,EAAE,MAAM,EAAE,OAAO,GAAE,YAAiB,GAAG,OAAO,CAAC,WAAW,EAAE,CAAC,CAsB/G;AAED,wBAAsB,iBAAiB,CAAC,cAAc,EAAE,MAAM,EAAE,OAAO,GAAE,YAAiB,GAAG,OAAO,CAAC,WAAW,EAAE,CAAC,CA+BlH;AAED,wBAAsB,OAAO,CAAC,OAAO,GAAE,YAAiB,GAAG,OAAO,CAAC,WAAW,CAAC,CAsB9E"}

package/dist/tools/index.d.ts

@@ -0,0 +1,9 @@
+export { diffpiSetupTool, diffpiValidateTool } from './setup';
+export declare const piTools: readonly [import("@earendil-works/pi-coding-agent").ToolDefinition<import("typebox").TObject<{
+    issueTracker: import("typebox").TOptional<import("typebox").TString>;
+    installMiseHook: import("typebox").TOptional<import("typebox").TBoolean>;
+}>, import("./setup").ToolDetails, any>, import("@earendil-works/pi-coding-agent").ToolDefinition<import("typebox").TObject<{
+    issueTracker: import("typebox").TOptional<import("typebox").TString>;
+    installMiseHook: import("typebox").TOptional<import("typebox").TBoolean>;
+}>, import("./setup").ToolDetails, any>];
+//# sourceMappingURL=index.d.ts.map

package/dist/tools/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/tools/index.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,eAAe,EAAE,kBAAkB,EAAE,MAAM,SAAS,CAAC;AAE9D,eAAO,MAAM,OAAO;;;;;;wCAAiD,CAAC"}