@aliou/pi-dev-kit 0.4.9 → 0.6.0

package/src/tools/package-manager-tool.ts

@@ -0,0 +1,194 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { ToolCallHeader } from "@aliou/pi-utils-ui";
+import type {
+  AgentToolResult,
+  ExtensionAPI,
+  ExtensionContext,
+  Theme,
+  ToolRenderResultOptions,
+} from "@mariozechner/pi-coding-agent";
+import { Text } from "@mariozechner/pi-tui";
+import { Type } from "@sinclair/typebox";
+
+const Params = Type.Object({});
+type PackageManagerParams = Record<string, never>;
+
+interface PackageManagerDetails {
+  packageManager?: string;
+  version?: string;
+  lockfile?: string;
+  installCommand?: string;
+  runCommand?: string;
+  cwd?: string;
+}
+
+const LOCKFILES: Record<string, string> = {
+  "pnpm-lock.yaml": "pnpm",
+  "yarn.lock": "yarn",
+  "package-lock.json": "npm",
+  "bun.lockb": "bun",
+  "bun.lock": "bun",
+};
+
+const COMMANDS: Record<string, { install: string; run: string }> = {
+  pnpm: { install: "pnpm install", run: "pnpm" },
+  yarn: { install: "yarn install", run: "yarn" },
+  npm: { install: "npm install", run: "npm run" },
+  bun: { install: "bun install", run: "bun run" },
+};
+
+export function setupPackageManagerTool(pi: ExtensionAPI) {
+  pi.registerTool<typeof Params, PackageManagerDetails>({
+    name: "detect_package_manager",
+    label: "Package Manager",
+    description:
+      "Detect the package manager used in the current project by checking lockfiles and package.json",
+    promptSnippet: "Detect the package manager for this project",
+    promptGuidelines: [
+      "Use when you need to know which package manager (npm, yarn, pnpm, bun) the project uses",
+      "Helpful before running install commands or scripts",
+    ],
+
+    parameters: Params,
+
+    async execute(
+      _toolCallId: string,
+      _params: PackageManagerParams,
+      _signal: AbortSignal | undefined,
+      _onUpdate: unknown,
+      ctx: ExtensionContext,
+    ): Promise<AgentToolResult<PackageManagerDetails>> {
+      const cwd = ctx.cwd;
+
+      const packageJsonPath = path.join(cwd, "package.json");
+      if (!fs.existsSync(packageJsonPath)) {
+        throw new Error(`No package.json found in ${cwd}`);
+      }
+
+      // Walk up from cwd to repo root, collecting packageManager and lockfile.
+      // Stop at .git boundary to avoid escaping the repository.
+      let declaredPm: string | undefined;
+      let declaredVersion: string | undefined;
+      let lockfile: string | undefined;
+      let lockfilePm: string | undefined;
+
+      let searchDir = cwd;
+      while (true) {
+        // Check packageManager field in package.json
+        if (!declaredPm) {
+          const pkgPath = path.join(searchDir, "package.json");
+          try {
+            if (fs.existsSync(pkgPath)) {
+              const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf-8"));
+              if (typeof pkg.packageManager === "string") {
+                const match = pkg.packageManager.match(/^([^@]+)@?(.*)?$/);
+                if (match) {
+                  declaredPm = match[1];
+                  declaredVersion = match[2] || undefined;
+                }
+              }
+            }
+          } catch {
+            // Ignore parse errors
+          }
+        }
+
+        // Check lockfiles
+        if (!lockfilePm) {
+          for (const [filename, pm] of Object.entries(LOCKFILES)) {
+            if (fs.existsSync(path.join(searchDir, filename))) {
+              lockfilePm = pm;
+              lockfile = filename;
+              break;
+            }
+          }
+        }
+
+        // Stop if we found both, hit .git, or hit filesystem root
+        if (
+          (declaredPm && lockfilePm) ||
+          fs.existsSync(path.join(searchDir, ".git"))
+        ) {
+          break;
+        }
+        const parent = path.dirname(searchDir);
+        if (parent === searchDir) break;
+        searchDir = parent;
+      }
+
+      const pm = declaredPm || lockfilePm || "npm";
+      const fallback = { install: `${pm} install`, run: pm };
+      const commands = COMMANDS[pm] ?? fallback;
+
+      const parts: string[] = [];
+      parts.push(`Package manager: ${pm}`);
+      if (declaredVersion) {
+        parts.push(`Declared version: ${declaredVersion}`);
+      }
+      if (lockfile) {
+        parts.push(`Lockfile: ${lockfile}`);
+      }
+      if (!lockfile && !declaredPm) {
+        parts.push(
+          "No lockfile or packageManager field found, defaulting to npm",
+        );
+      }
+      parts.push(`Install: ${commands.install}`);
+      parts.push(`Run: ${commands.run}`);
+
+      const message = parts.join("\n");
+
+      return {
+        content: [{ type: "text", text: message }],
+        details: {
+          packageManager: pm,
+          version: declaredVersion,
+          lockfile,
+          installCommand: commands.install,
+          runCommand: commands.run,
+          cwd,
+        },
+      };
+    },
+
+    renderCall(_args: PackageManagerParams, theme: Theme) {
+      return new ToolCallHeader({ toolName: "Detect Package Manager" }, theme);
+    },
+
+    renderResult(
+      result: AgentToolResult<PackageManagerDetails>,
+      _options: ToolRenderResultOptions,
+      theme: Theme,
+    ): Text {
+      const { details } = result;
+
+      // Check for missing expected fields (framework passes {} on error)
+      if (!details?.packageManager) {
+        // Extract error message from result.content
+        const text = result.content[0];
+        const errorMessage =
+          text?.type === "text" && text.text
+            ? text.text
+            : "Failed to detect package manager";
+        return new Text(theme.fg("error", errorMessage), 0, 0);
+      }
+
+      const lines: string[] = [];
+      lines.push(
+        theme.fg(
+          "success",
+          `Package manager: ${theme.bold(details.packageManager)}`,
+        ),
+      );
+      if (details.version) {
+        lines.push(theme.fg("dim", `Version: ${details.version}`));
+      }
+      if (details.lockfile) {
+        lines.push(theme.fg("dim", `Lockfile: ${details.lockfile}`));
+      }
+
+      return new Text(lines.join("\n"), 0, 0);
+    },
+  });
+}

package/src/tools/utils.ts

@@ -0,0 +1,38 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+
+/**
+ * Find the currently running Pi installation directory by resolving the
+ * pi-coding-agent package location.
+ */
+export function findPiInstallation(): string | null {
+  try {
+    const piModulePath = require.resolve(
+      "@mariozechner/pi-coding-agent/package.json",
+    );
+    return path.dirname(piModulePath);
+  } catch (_error) {
+    const scriptPath = process.argv[1];
+    if (scriptPath) {
+      let currentDir = path.dirname(scriptPath);
+
+      while (currentDir !== path.dirname(currentDir)) {
+        const packageJsonPath = path.join(currentDir, "package.json");
+        if (fs.existsSync(packageJsonPath)) {
+          try {
+            const packageContent = fs.readFileSync(packageJsonPath, "utf-8");
+            const packageJson = JSON.parse(packageContent);
+            if (packageJson.name === "@mariozechner/pi-coding-agent") {
+              return currentDir;
+            }
+          } catch {
+            // Continue searching
+          }
+        }
+        currentDir = path.dirname(currentDir);
+      }
+    }
+
+    return null;
+  }
+}

package/src/tools/version-tool.ts

@@ -0,0 +1,70 @@
+import { ToolCallHeader } from "@aliou/pi-utils-ui";
+import type {
+  AgentToolResult,
+  ExtensionAPI,
+  ExtensionContext,
+  Theme,
+  ToolRenderResultOptions,
+} from "@mariozechner/pi-coding-agent";
+import { VERSION } from "@mariozechner/pi-coding-agent";
+import { Text } from "@mariozechner/pi-tui";
+import { Type } from "@sinclair/typebox";
+
+const VersionParams = Type.Object({});
+type VersionParamsType = Record<string, never>;
+
+interface VersionDetails {
+  version?: string;
+}
+
+export function setupVersionTool(pi: ExtensionAPI) {
+  pi.registerTool<typeof VersionParams, VersionDetails>({
+    name: "pi_version",
+    label: "Pi Version",
+    description: "Get the version of the currently running Pi instance",
+    promptSnippet: "Check the current Pi version.",
+    promptGuidelines: [
+      "Use when the user asks about the Pi version or when a task depends on knowing the installed version.",
+    ],
+
+    parameters: VersionParams,
+
+    async execute(
+      _toolCallId: string,
+      _params: VersionParamsType,
+      _signal: AbortSignal | undefined,
+      _onUpdate: unknown,
+      _ctx: ExtensionContext,
+    ): Promise<AgentToolResult<VersionDetails>> {
+      return {
+        content: [{ type: "text", text: `Pi version ${VERSION}` }],
+        details: { version: VERSION },
+      };
+    },
+
+    renderCall(_args: VersionParamsType, theme: Theme) {
+      return new ToolCallHeader({ toolName: "Pi Version" }, theme);
+    },
+
+    renderResult(
+      result: AgentToolResult<VersionDetails>,
+      _options: ToolRenderResultOptions,
+      theme: Theme,
+    ): Text {
+      const { details } = result;
+
+      if (!details?.version) {
+        const textBlock = result.content.find((c) => c.type === "text");
+        const msg =
+          (textBlock?.type === "text" && textBlock.text) || "Unknown version";
+        return new Text(theme.fg("error", msg), 0, 0);
+      }
+
+      return new Text(
+        theme.fg("accent", `Pi version: ${details.version}`),
+        0,
+        0,
+      );
+    },
+  });
+}