@pi-unipi/cocoindex 2.0.0

package/commands.ts

@@ -0,0 +1,175 @@
+/**
+ * commands.ts — CocoIndex command registration
+ *
+ * Exposes cocoindex operations as Pi commands:
+ * - /unipi:cocoindex-update  — Run indexing
+ * - /unipi:cocoindex-status  — Show status
+ * - /unipi:cocoindex-init    — Scaffold pipeline
+ * - /unipi:cocoindex-settings — TUI settings
+ *
+ * Commands are registered at extension load time (synchronous).
+ * Project directory is resolved from ctx.cwd at handler invocation time.
+ */
+
+import type { ExtensionAPI, ExtensionCommandContext } from "@mariozechner/pi-coding-agent";
+import { COCOINDEX_COMMANDS, COCOINDEX_PACKAGE_SPEC } from "@pi-unipi/core";
+import * as bridge from "./bridge.js";
+import { ensureCocoindex } from "./installer.js";
+
+export function registerCocoindexCommands(pi: ExtensionAPI): void {
+  // ── /unipi:cocoindex-update ────────────────────────────
+  pi.registerCommand(`unipi:${COCOINDEX_COMMANDS.UPDATE}`, {
+    description: "Run CocoIndex update to index the current project",
+    handler: async (_args: string, ctx: ExtensionCommandContext) => {
+      const projectDir = (ctx as any).cwd ?? process.cwd();
+      const ensured = await ensureCocoindex(ctx);
+      if (!ensured.ok) return;
+
+      const pipelineDir = bridge.getPipelineDir(projectDir);
+      const initialized = await bridge.isPipelineInitialized(pipelineDir);
+      if (!initialized) {
+        ctx.ui.notify("⚠️ Pipeline not initialized. Run /unipi:cocoindex-init first.", "warning");
+        return;
+      }
+
+      ctx.ui.notify("🔄 Running CocoIndex update...", "info");
+
+      const result = await bridge.indexProject(projectDir);
+      if (result.success) {
+        ctx.ui.notify(
+          `✅ CocoIndex update complete: ${result.chunksProcessed} chunks in ${(result.durationMs / 1000).toFixed(1)}s`,
+          "info",
+        );
+      } else {
+        ctx.ui.notify(`❌ CocoIndex update failed: ${result.error}`, "error");
+      }
+    },
+  });
+
+  // ── /unipi:cocoindex-status ────────────────────────────
+  pi.registerCommand(`unipi:${COCOINDEX_COMMANDS.STATUS}`, {
+    description: "Show CocoIndex indexing status",
+    handler: async (_args: string, ctx: ExtensionCommandContext) => {
+      const projectDir = (ctx as any).cwd ?? process.cwd();
+      const info = await bridge.status(projectDir);
+      const lines = [
+        "📦 CocoIndex Status",
+        `CLI: ${info.cliAvailable ? "✅ installed" : "❌ not found"}`,
+        `Pipeline: ${info.pipelineConfigured ? "✅ configured" : "❌ not initialized"}`,
+        `Target: ${info.targetStore}`,
+        `Data: ${info.indexed ? `✅ ${info.docCount} documents` : "— no data"}`,
+        `Last run: ${info.lastRun ?? "never"}`,
+      ];
+
+      if (!info.cliAvailable) {
+        lines.push(
+          "",
+          "Setup: run /unipi:cocoindex-init for guided install.",
+          `Manual: uv tool install '${COCOINDEX_PACKAGE_SPEC}'`,
+          "Fallback: mise use -g uv@latest",
+        );
+      }
+      if (!info.pipelineConfigured) {
+        lines.push("", "Initialize: /unipi:cocoindex-init");
+      }
+
+      ctx.ui.notify(lines.join("\n"), "info");
+    },
+  });
+
+  // ── /unipi:cocoindex-init ──────────────────────────────
+  pi.registerCommand(`unipi:${COCOINDEX_COMMANDS.INIT}`, {
+    description: "Initialize CocoIndex pipeline for the current project",
+    handler: async (_args: string, ctx: ExtensionCommandContext) => {
+      const projectDir = (ctx as any).cwd ?? process.cwd();
+      const ensured = await ensureCocoindex(ctx);
+      if (!ensured.ok) return;
+
+      const result = await bridge.initPipeline(projectDir);
+      if (result.success) {
+        ctx.ui.notify(
+          "✅ CocoIndex pipeline initialized at .unipi/cocoindex/main.py\n" +
+          "Run /unipi:cocoindex-update to start indexing.",
+          "info",
+        );
+      } else {
+        ctx.ui.notify(`❌ Init failed: ${result.error}`, "error");
+      }
+    },
+  });
+
+  // ── /unipi:cocoindex-search ──────────────────────────
+  pi.registerCommand(`unipi:${COCOINDEX_COMMANDS.SEARCH}`, {
+    description: "Search indexed codebase with semantic/vector, full-text, or lexical search",
+    handler: async (args: string, ctx: ExtensionCommandContext) => {
+      const projectDir = (ctx as any).cwd ?? process.cwd();
+      const query = args.trim();
+
+      if (!query) {
+        ctx.ui.notify("Usage: /unipi:cocoindex-search <query>", "warning");
+        return;
+      }
+
+      const pipelineDir = bridge.getPipelineDir(projectDir);
+      const lancedbPath = bridge.getPipelineDir(projectDir) + "/.lancedb";
+      const { existsSync } = await import("fs");
+      if (!existsSync(lancedbPath)) {
+        ctx.ui.notify("❌ No index found. Run /unipi:cocoindex-update first.", "error");
+        return;
+      }
+
+      ctx.ui.notify(`🔍 Searching: "${query}"...`, "info");
+
+      try {
+        const results = await bridge.search(projectDir, query, { limit: 10 });
+
+        if (results.length === 0) {
+          ctx.ui.notify(
+            `No results for "${query}" in the current CocoIndex data. Run /unipi:cocoindex-update if the index may be stale.`,
+            "info",
+          );
+          return;
+        }
+
+        const lines = results.map((r, i) => {
+          const dist = r.rank != null ? ` (${r.rank.toFixed(3)})` : "";
+          const file = r.source || r.title;
+          const snippet = r.content.slice(0, 150).replace(/\n/g, " ");
+          return `${i + 1}. ${file}${dist}\n   ${snippet}...`;
+        });
+        ctx.ui.notify(
+          `🔍 ${results.length} results for "${query}":\n\n${lines.join("\n\n")}`,
+          "info",
+        );
+      } catch (err: any) {
+        ctx.ui.notify(`❌ Search failed: ${err.message}`, "error");
+      }
+    },
+  });
+
+  // ── /unipi:cocoindex-settings ──────────────────────────
+  pi.registerCommand(`unipi:${COCOINDEX_COMMANDS.SETTINGS}`, {
+    description: "Show CocoIndex configuration and settings",
+    handler: async (_args: string, ctx: ExtensionCommandContext) => {
+      const projectDir = (ctx as any).cwd ?? process.cwd();
+      const pipelineDir = bridge.getPipelineDir(projectDir);
+      const info = await bridge.status(projectDir);
+      const lines = [
+        "⚙️ CocoIndex Settings",
+        "",
+        `Pipeline: ${pipelineDir}/main.py`,
+        `Target store: ${info.targetStore}`,
+        `Embedding model: (from memory config)`,
+        "",
+        "Configuration:",
+        "  • Pipeline file: .unipi/cocoindex/main.py",
+        "  • Data store: .unipi/cocoindex/.lancedb/",
+        "  • Embedding config: ~/.unipi/memory/config.json",
+        "",
+        "To customize, edit .unipi/cocoindex/main.py directly.",
+      ];
+
+      ctx.ui.notify(lines.join("\n"), "info");
+    },
+  });
+}

package/index.ts

@@ -0,0 +1,55 @@
+/**
+ * @pi-unipi/cocoindex — CocoIndex integration for Pi
+ *
+ * Bridges Pi to CocoIndex CLI for AST-aware content indexing,
+ * semantic vector search, and incremental pipeline management.
+ *
+ * Default target store: LanceDB (zero-config, local file-based).
+ * Embedding model: reuses memory package settings (OpenRouter API key + model).
+ */
+
+import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+import { MODULES, UNIPI_EVENTS, COCOINDEX_TOOLS, COCOINDEX_COMMANDS, COCOINDEX_PACKAGE_SPEC, emitEvent } from "@pi-unipi/core";
+import { registerCocoindexTools } from "./tools.js";
+import { registerCocoindexCommands } from "./commands.js";
+import * as bridge from "./bridge.js";
+
+export default function cocoindexExtension(pi: ExtensionAPI): void {
+  // Register commands at extension load time (synchronous).
+  // Commands resolve projectDir from ctx.cwd at handler invocation time.
+  registerCocoindexCommands(pi);
+
+  pi.on("session_start", async (_event, ctx) => {
+    const projectDir = (ctx as any).cwd ?? process.cwd();
+
+    // Register tools — these need projectDir for search context
+    const pipelineDir = bridge.getPipelineDir(projectDir);
+    const initialized = await bridge.isPipelineInitialized(pipelineDir);
+
+    registerCocoindexTools(pi, {
+      projectDir,
+      pipelineDir,
+      initialized,
+    });
+
+    emitEvent(pi, UNIPI_EVENTS.MODULE_READY, {
+      name: MODULES.COCOINDEX,
+      version: "0.1.0",
+      commands: Object.values(COCOINDEX_COMMANDS),
+      tools: Object.values(COCOINDEX_TOOLS),
+    });
+
+    const available = await bridge.isAvailable();
+    if (available) {
+      ctx.ui.notify("📦 CocoIndex ready", "info");
+    } else {
+      ctx.ui.notify(
+        `📦 CocoIndex: CLI not found — run /unipi:cocoindex-init for guided install (manual: uv tool install '${COCOINDEX_PACKAGE_SPEC}').`,
+        "info",
+      );
+    }
+  });
+}
+
+export { bridge };
+export * as installer from "./installer.js";

package/installer.ts

@@ -0,0 +1,397 @@
+/**
+ * installer.ts — Consent-based CocoIndex CLI installer helpers.
+ *
+ * Pure planning helpers are separated from side-effecting execution so command
+ * handlers can show the exact install plan before running anything.
+ */
+
+import { execFileSync, spawn } from "node:child_process";
+import { homedir } from "node:os";
+import { delimiter, join } from "node:path";
+import type { ExtensionCommandContext } from "@mariozechner/pi-coding-agent";
+import { COCOINDEX_MIN_VERSION, COCOINDEX_PACKAGE_SPEC } from "@pi-unipi/core";
+import * as bridge from "./bridge.js";
+
+export type SupportedShell = "bash" | "zsh" | "fish" | "unknown";
+export type InstallPlanKind = "auto" | "manual";
+
+export interface InstallStep {
+  /** Executable name/path. */
+  command: string;
+  /** Argv passed to the executable. Prefer this over shell strings. */
+  args?: string[];
+  /** User-facing command display for consent/errors. */
+  displayCommand: string;
+  /** User-facing description of the step. */
+  description: string;
+  /** Optional steps may fail without aborting the whole plan. */
+  optional?: boolean;
+  /** Timeout for this step. Defaults to 10 minutes. */
+  timeoutMs?: number;
+}
+
+export interface InstallPlan {
+  kind: InstallPlanKind;
+  steps: InstallStep[];
+  summary: string;
+  shell: SupportedShell;
+  manualInstructions?: string[];
+}
+
+export interface InstallResult {
+  ok: boolean;
+  binPath?: string;
+  version?: string;
+  error?: string;
+  skipped?: boolean;
+  stdout?: string;
+  stderr?: string;
+  failedStep?: InstallStep;
+  manualInstructions?: string[];
+}
+
+export type InstallProgress = (message: string, step?: InstallStep) => void;
+
+const DEFAULT_STEP_TIMEOUT_MS = 10 * 60 * 1000;
+
+/** Detect the user's login shell for shell-aware manual instructions. */
+export function detectShell(): SupportedShell {
+  const shell = process.env.SHELL ?? "";
+  if (shell.includes("zsh")) return "zsh";
+  if (shell.includes("bash")) return "bash";
+  if (shell.includes("fish")) return "fish";
+  return "unknown";
+}
+
+/** Safely check whether a command is on PATH. */
+export function hasTool(name: string): boolean {
+  // Defend against accidental shell metacharacters even though the name is
+  // supplied internally today.
+  if (!/^[A-Za-z0-9._+-]+$/.test(name)) return false;
+
+  try {
+    const result = execFileSync("sh", ["-c", "command -v -- \"$1\"", "sh", name], {
+      encoding: "utf-8",
+      timeout: 3000,
+      stdio: ["pipe", "pipe", "pipe"],
+      env: installerEnv(),
+    });
+    return result.trim().length > 0;
+  } catch {
+    return false;
+  }
+}
+
+/** Compute an install plan without executing any commands. */
+export function dryRun(): InstallPlan {
+  const shell = detectShell();
+
+  if (hasTool("uv")) {
+    return automaticPlan(shell, [uvInstallStep()]);
+  }
+
+  if (hasTool("mise")) {
+    return automaticPlan(shell, [
+      {
+        command: "mise",
+        args: ["use", "-g", "uv@latest"],
+        displayCommand: "mise use -g uv@latest",
+        description: "Install and activate uv with mise",
+      },
+      uvInstallStep(),
+    ]);
+  }
+
+  const manualInstructions = buildManualInstructions(shell);
+  return {
+    kind: "manual",
+    steps: [],
+    shell,
+    manualInstructions,
+    summary: [
+      "CocoIndex CLI is not installed, and neither uv nor mise was found on PATH.",
+      "",
+      ...manualInstructions,
+    ].join("\n"),
+  };
+}
+
+/** Execute an automatic install plan sequentially. */
+export async function execute(plan: InstallPlan, onProgress?: InstallProgress): Promise<InstallResult> {
+  if (plan.kind === "manual") {
+    return {
+      ok: false,
+      error: "Manual CocoIndex installation is required.",
+      manualInstructions: plan.manualInstructions,
+    };
+  }
+
+  for (const step of plan.steps) {
+    onProgress?.(step.description, step);
+    const result = await runStep(step);
+
+    if (result.ok) continue;
+    if (step.optional) continue;
+
+    const isMiseStep = step.command === "mise";
+    const manualInstructions = isMiseStep ? buildUvInstallerFallback(plan.shell) : undefined;
+    const fallback = manualInstructions
+      ? `\n\nFallback uv installer:\n${manualInstructions.join("\n")}`
+      : "";
+
+    return {
+      ok: false,
+      error: `Install step failed: ${step.displayCommand}\n${summarizeCommandOutput(result)}${fallback}`,
+      stdout: result.stdout,
+      stderr: result.stderr,
+      failedStep: step,
+      manualInstructions,
+    };
+  }
+
+  return { ok: true };
+}
+
+/**
+ * Ensure CocoIndex v1.0+ exists, prompting the user before any install.
+ * Tools should not call this; it is intended for interactive commands only.
+ */
+export async function ensureCocoindex(ctx: ExtensionCommandContext): Promise<InstallResult> {
+  const existing = await getExistingInstall();
+  if (existing.ok) return existing;
+  if (existing.error === "upgrade-needed") {
+    const message = upgradeMessage(existing.version);
+    notify(ctx, message, "warning");
+    return { ok: false, error: message, version: existing.version };
+  }
+
+  const plan = dryRun();
+  if (plan.kind === "manual") {
+    const message = plan.summary;
+    notify(ctx, message, "warning");
+    return { ok: false, error: "Manual CocoIndex installation is required.", manualInstructions: plan.manualInstructions };
+  }
+
+  if (!hasConfirm(ctx)) {
+    const message = [
+      "CocoIndex CLI is not installed and this command is running without an interactive confirmation UI.",
+      "Please install manually, then re-run /unipi:cocoindex-init:",
+      `  uv tool install '${COCOINDEX_PACKAGE_SPEC}'`,
+    ].join("\n");
+    notify(ctx, message, "warning");
+    return { ok: false, error: message };
+  }
+
+  const confirmed = await ctx.ui.confirm("Install CocoIndex?", plan.summary);
+  if (!confirmed) {
+    notify(ctx, "CocoIndex install skipped. /unipi:cocoindex-init can try again later.", "info");
+    return { ok: false, skipped: true };
+  }
+
+  try {
+    const result = await execute(plan, (message) => {
+      setStatus(ctx, message);
+    });
+
+    if (!result.ok) {
+      notify(ctx, `❌ CocoIndex install failed:\n${result.error ?? "Unknown error"}`, "error");
+      return result;
+    }
+
+    bridge.resetAvailabilityCache();
+    const verified = await getExistingInstall();
+    if (verified.ok) {
+      notify(ctx, `✅ CocoIndex ${verified.version ?? ""} installed and ready.`, "info");
+      return verified;
+    }
+
+    const message = verified.error === "upgrade-needed"
+      ? upgradeMessage(verified.version)
+      : "CocoIndex installation finished, but the CLI could not be verified. Make sure ~/.local/bin is on PATH.";
+    notify(ctx, message, verified.error === "upgrade-needed" ? "warning" : "error");
+    return { ok: false, error: message, version: verified.version };
+  } finally {
+    setStatus(ctx, undefined);
+  }
+}
+
+async function getExistingInstall(): Promise<InstallResult & { error?: string }> {
+  const available = await bridge.isAvailable({ useCache: false });
+  if (!available) return { ok: false, error: "missing" };
+
+  const versionOutput = await bridge.getVersion();
+  const version = versionOutput ? bridge.parseVersion(versionOutput) : null;
+  if (!bridge.isVersionAtLeast(version, COCOINDEX_MIN_VERSION)) {
+    return { ok: false, error: "upgrade-needed", version: version ?? versionOutput ?? undefined };
+  }
+
+  return {
+    ok: true,
+    binPath: bridge.getCocoindexBinPath(),
+    version: version ?? versionOutput ?? undefined,
+  };
+}
+
+function upgradeMessage(version: string | undefined): string {
+  return [
+    `CocoIndex ${COCOINDEX_MIN_VERSION}+ is required${version ? ` (found ${version})` : ""}.`,
+    "Please upgrade before continuing:",
+    "  uv tool upgrade cocoindex",
+    `or reinstall with: uv tool install '${COCOINDEX_PACKAGE_SPEC}' --force`,
+  ].join("\n");
+}
+
+function hasConfirm(ctx: ExtensionCommandContext): boolean {
+  const anyCtx = ctx as any;
+  return anyCtx.hasUI === true && typeof anyCtx.ui?.confirm === "function";
+}
+
+function notify(ctx: ExtensionCommandContext, message: string, type: "info" | "warning" | "error"): void {
+  const anyCtx = ctx as any;
+  if (typeof anyCtx.ui?.notify === "function") anyCtx.ui.notify(message, type);
+}
+
+function setStatus(ctx: ExtensionCommandContext, message: string | undefined): void {
+  const anyCtx = ctx as any;
+  if (anyCtx.hasUI === true && typeof anyCtx.ui?.setStatus === "function") {
+    anyCtx.ui.setStatus("cocoindex-installer", message);
+  }
+}
+
+function automaticPlan(shell: SupportedShell, steps: InstallStep[]): InstallPlan {
+  const commandLines = steps.map((step) => `  • ${step.displayCommand}`);
+  return {
+    kind: "auto",
+    steps,
+    shell,
+    summary: [
+      "Pi can install CocoIndex CLI with LanceDB support for this user account.",
+      "",
+      `Package: ${COCOINDEX_PACKAGE_SPEC}`,
+      "Commands to run:",
+      ...commandLines,
+      "",
+      "This uses isolated uv tool environments and exposes the `cocoindex` binary under ~/.local/bin/.",
+    ].join("\n"),
+  };
+}
+
+function uvInstallStep(): InstallStep {
+  return {
+    command: "uv",
+    args: ["tool", "install", COCOINDEX_PACKAGE_SPEC],
+    displayCommand: `uv tool install '${COCOINDEX_PACKAGE_SPEC}'`,
+    description: "Install CocoIndex CLI with LanceDB support using uv",
+  };
+}
+
+function buildManualInstructions(shell: SupportedShell): string[] {
+  const uvInstructions = buildUvInstallerFallback(shell);
+  return [
+    "Manual installation required:",
+    "1. Install uv:",
+    ...uvInstructions.map((line) => `   ${line}`),
+    "2. Restart your shell if instructed by the installer.",
+    `3. Run: uv tool install '${COCOINDEX_PACKAGE_SPEC}'`,
+    "4. Re-run /unipi:cocoindex-init.",
+    "",
+    "If you prefer mise, install mise from https://mise.jdx.dev/getting-started.html, then run:",
+    "   mise use -g uv@latest",
+    `   uv tool install '${COCOINDEX_PACKAGE_SPEC}'`,
+  ];
+}
+
+function buildUvInstallerFallback(shell: SupportedShell): string[] {
+  if (shell === "fish") {
+    return [
+      "curl -LsSf https://astral.sh/uv/install.sh | sh",
+      "fish_add_path ~/.local/bin",
+    ];
+  }
+
+  if (shell === "bash" || shell === "zsh") {
+    return [
+      "curl -LsSf https://astral.sh/uv/install.sh | sh",
+      "export PATH=\"$HOME/.local/bin:$PATH\"",
+    ];
+  }
+
+  return [
+    "curl -LsSf https://astral.sh/uv/install.sh | sh",
+    "Add ~/.local/bin to PATH for your shell.",
+  ];
+}
+
+interface StepRunResult {
+  ok: boolean;
+  stdout: string;
+  stderr: string;
+  exitCode?: number | null;
+  signal?: NodeJS.Signals | null;
+}
+
+function runStep(step: InstallStep): Promise<StepRunResult> {
+  return new Promise((resolve) => {
+    const proc = spawn(step.command, step.args ?? [], {
+      stdio: ["ignore", "pipe", "pipe"],
+      env: installerEnv(),
+    });
+
+    let stdout = "";
+    let stderr = "";
+    let settled = false;
+
+    const timeout = setTimeout(() => {
+      if (settled) return;
+      proc.kill("SIGTERM");
+      stderr += `\nTimed out after ${step.timeoutMs ?? DEFAULT_STEP_TIMEOUT_MS}ms.`;
+    }, step.timeoutMs ?? DEFAULT_STEP_TIMEOUT_MS);
+
+    proc.stdout.on("data", (data: Buffer) => {
+      stdout += data.toString();
+    });
+
+    proc.stderr.on("data", (data: Buffer) => {
+      stderr += data.toString();
+    });
+
+    proc.on("close", (code: number | null, signal: NodeJS.Signals | null) => {
+      settled = true;
+      clearTimeout(timeout);
+      resolve({ ok: code === 0, stdout, stderr, exitCode: code, signal });
+    });
+
+    proc.on("error", (err: Error) => {
+      settled = true;
+      clearTimeout(timeout);
+      resolve({ ok: false, stdout, stderr: stderr || err.message });
+    });
+  });
+}
+
+function installerEnv(): NodeJS.ProcessEnv {
+  const home = homedir();
+  const extraPaths = [
+    join(home, ".local", "bin"),
+    join(home, ".local", "share", "mise", "shims"),
+  ];
+  const currentPath = process.env.PATH ?? "";
+  return {
+    ...process.env,
+    PATH: [...extraPaths, currentPath].filter(Boolean).join(delimiter),
+  };
+}
+
+function summarizeCommandOutput(result: StepRunResult): string {
+  const parts: string[] = [];
+  if (result.exitCode !== undefined) parts.push(`exit code: ${result.exitCode}`);
+  if (result.signal) parts.push(`signal: ${result.signal}`);
+  if (result.stderr.trim()) parts.push(`stderr:\n${tail(result.stderr.trim())}`);
+  if (result.stdout.trim()) parts.push(`stdout:\n${tail(result.stdout.trim())}`);
+  return parts.join("\n") || "No command output was captured.";
+}
+
+function tail(value: string, maxChars = 4000): string {
+  if (value.length <= maxChars) return value;
+  return `…${value.slice(value.length - maxChars)}`;
+}

package/package.json

@@ -0,0 +1,42 @@
+{
+  "name": "@pi-unipi/cocoindex",
+  "version": "2.0.0",
+  "description": "CocoIndex integration for Pi — AST-aware content indexing, semantic vector search, and incremental pipeline management",
+  "type": "module",
+  "main": "index.ts",
+  "types": "index.ts",
+  "license": "MIT",
+  "author": "Neuron Mr White",
+  "keywords": [
+    "pi-package",
+    "pi-extension",
+    "pi-coding-agent",
+    "cocoindex",
+    "content-indexing",
+    "vector-search"
+  ],
+  "scripts": {
+    "typecheck": "tsc --noEmit"
+  },
+  "peerDependencies": {
+    "@mariozechner/pi-coding-agent": "*",
+    "@mariozechner/pi-ai": "*",
+    "@mariozechner/pi-tui": "*",
+    "@sinclair/typebox": "*"
+  },
+  "dependencies": {
+    "@pi-unipi/core": "*"
+  },
+  "optionalDependencies": {
+    "@lancedb/lancedb": "^0.21.0"
+  },
+  "files": [
+    "index.ts",
+    "bridge.ts",
+    "installer.ts",
+    "tools.ts",
+    "commands.ts",
+    "skills/**/*",
+    "README.md"
+  ]
+}