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

package/dist/tools/index.js

@@ -0,0 +1,594 @@
+// src/tools/setup.ts
+import { defineTool } from "@earendil-works/pi-coding-agent";
+import { Type } from "typebox";
+
+// src/setup.ts
+import { homedir as homedir4 } from "node:os";
+import { join as join5 } from "node:path";
+
+// 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
+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 : {};
+}
+
+// src/tools/setup.ts
+var parameters = Type.Object({
+  issueTracker: Type.Optional(Type.String({
+    description: "Issue tracker MCP server to configure. Use none unless the user explicitly selects Linear or Jira.",
+    enum: ["none", "linear", "jira"],
+    default: "none"
+  })),
+  installMiseHook: Type.Optional(Type.Boolean({
+    description: "Add the mise activation hook to the current shell configuration. Set false only when the user declines.",
+    default: true
+  }))
+});
+var diffpiSetupTool = defineTool({
+  name: "diffpi_setup",
+  label: "diffpi setup",
+  description: "Install or repair the @difflab/pi environment. This mutates user-level tool installations and configuration files.",
+  promptSnippet: "Install or repair @difflab/pi only after the user approves the setup choices",
+  promptGuidelines: [
+    "Call this tool only when the user explicitly asks to install, configure, or repair the environment.",
+    "Use ask_user_question for unspecified setup choices before calling this tool.",
+    'Use issueTracker="none" unless the user explicitly selects Linear or Jira.',
+    "Use diffpi_validate instead when the user asks only to inspect or verify setup."
+  ],
+  parameters,
+  executionMode: "sequential",
+  async execute(_toolCallId, params, _signal, onUpdate) {
+    const result = await setupPi({
+      issueTracker: parseIssueTracker(params.issueTracker),
+      installMiseHook: params.installMiseHook ?? true,
+      onProgress(message) {
+        onUpdate?.({ content: [{ type: "text", text: message }], details: {} });
+      }
+    });
+    return formatResult(result, "Setup complete.");
+  }
+});
+var diffpiValidateTool = defineTool({
+  name: "diffpi_validate",
+  label: "diffpi validate",
+  description: "Inspect the @difflab/pi environment without installing software or changing configuration files.",
+  promptSnippet: "Validate @difflab/pi safely before setup or when the user asks for an environment check",
+  promptGuidelines: [
+    "Prefer this tool before diffpi_setup when the requested action is unclear.",
+    "This tool is read-only. Do not describe planned actions as completed changes.",
+    'Use issueTracker="none" unless the user explicitly asks to validate Linear or Jira configuration.'
+  ],
+  parameters,
+  executionMode: "sequential",
+  async execute(_toolCallId, params) {
+    const result = await setupPi({
+      issueTracker: parseIssueTracker(params.issueTracker),
+      installMiseHook: params.installMiseHook ?? true,
+      dryRun: true
+    });
+    const incomplete = result.actions.some((item) => item.status === "planned");
+    return formatResult(result, incomplete ? "Setup is incomplete." : "Setup is ready.");
+  }
+});
+function parseIssueTracker(value) {
+  if (!value || value === "none")
+    return "none";
+  if (value === "linear" || value === "jira")
+    return value;
+  throw new Error(`Unknown issue tracker: ${value}`);
+}
+function formatResult(result, heading) {
+  const changed = result.actions.some((item) => item.status === "installed" || item.status === "updated" || item.status === "planned");
+  const lines = result.actions.map((item) => `${item.status.padEnd(9)} ${item.name}: ${item.detail}`);
+  if (result.restartPi)
+    lines.push("Restart pi to load package, skill, and MCP changes.");
+  return {
+    content: [{ type: "text", text: `${heading}
+
+${lines.join(`
+`)}` }],
+    details: { changed, result }
+  };
+}
+
+// src/tools/index.ts
+var piTools = [diffpiSetupTool, diffpiValidateTool];
+export {
+  diffpiSetupTool,
+  diffpiValidateTool,
+  piTools
+};

package/dist/tools/setup.d.ts

@@ -0,0 +1,15 @@
+import { type ToolDefinition } from '@earendil-works/pi-coding-agent';
+import { Type } from 'typebox';
+import { type SetupResult } from '../setup';
+declare const parameters: Type.TObject<{
+    issueTracker: Type.TOptional<Type.TString>;
+    installMiseHook: Type.TOptional<Type.TBoolean>;
+}>;
+export interface ToolDetails {
+    changed?: boolean;
+    result?: SetupResult;
+}
+export declare const diffpiSetupTool: ToolDefinition<typeof parameters, ToolDetails>;
+export declare const diffpiValidateTool: ToolDefinition<typeof parameters, ToolDetails>;
+export {};
+//# sourceMappingURL=setup.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"setup.d.ts","sourceRoot":"","sources":["../../src/tools/setup.ts"],"names":[],"mappings":"AAAA,OAAO,EAAc,KAAK,cAAc,EAAE,MAAM,iCAAiC,CAAC;AAClF,OAAO,EAAE,IAAI,EAAE,MAAM,SAAS,CAAC;AAC/B,OAAO,EAAW,KAAK,WAAW,EAAE,MAAM,UAAU,CAAC;AAErD,QAAA,MAAM,UAAU;;;EAed,CAAC;AAEH,MAAM,WAAW,WAAW;IAC1B,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,MAAM,CAAC,EAAE,WAAW,CAAC;CACtB;AAED,eAAO,MAAM,eAAe,EAAE,cAAc,CAAC,OAAO,UAAU,EAAE,WAAW,CAyBzE,CAAC;AAEH,eAAO,MAAM,kBAAkB,EAAE,cAAc,CAAC,OAAO,UAAU,EAAE,WAAW,CAqB5E,CAAC"}

package/package.json

@@ -0,0 +1,80 @@
+{
+  "name": "@difflab/pi",
+  "version": "0.1.0-rc.202609140747.4d45e72.2",
+  "description": "Tools and skills for the pi coding agent",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/difflab-io/diffpi.git",
+    "directory": "packages/pi"
+  },
+  "homepage": "https://github.com/difflab-io/diffpi#readme",
+  "bugs": {
+    "url": "https://github.com/difflab-io/diffpi/issues"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./tools": {
+      "types": "./dist/tools/index.d.ts",
+      "default": "./dist/tools/index.js"
+    }
+  },
+  "files": [
+    "dist/",
+    "skills/"
+  ],
+  "pi": {
+    "extensions": [
+      "./dist/extensions/index.js"
+    ],
+    "skills": [
+      "./skills"
+    ]
+  },
+  "keywords": [
+    "pi-package",
+    "pi",
+    "developer-tools"
+  ],
+  "author": "",
+  "license": "MIT",
+  "packageManager": "bun@1.4.0",
+  "engines": {
+    "node": ">=22.5.0"
+  },
+  "dependencies": {
+    "pi-mcp-adapter": "^2.33.0"
+  },
+  "devDependencies": {
+    "@eslint/js": "^9.0.0",
+    "@semantic-release/changelog": "^6.0.0",
+    "@semantic-release/exec": "^7.1.0",
+    "@semantic-release/git": "^10.0.0",
+    "@semantic-release/github": "^10.0.0",
+    "@earendil-works/pi-coding-agent": "^0.84.4",
+    "@types/bun": "^1.3.10",
+    "@types/node": "^22.0.0",
+    "@typescript-eslint/eslint-plugin": "^8.0.0",
+    "@typescript-eslint/parser": "^8.0.0",
+    "conventional-changelog-conventionalcommits": "^8.0.0",
+    "eslint": "^9.0.0",
+    "globals": "^15.0.0",
+    "prettier": "^3.0.0",
+    "semantic-release": "^24.0.0",
+    "typebox": "^1.0.0",
+    "typescript": "^5.0.0",
+    "typescript-eslint": "^8.0.0"
+  },
+  "peerDependencies": {
+    "@earendil-works/pi-coding-agent": "*",
+    "typebox": "*"
+  }
+}