@pi-unipi/unipi 2.6.0 → 2.6.2

package/packages/cocoindex/skills/cocoindex/SKILL.md

@@ -1,88 +0,0 @@
----
-name: cocoindex
-description: "CocoIndex content indexing and search — use when you need to search indexed project content or trigger re-indexing"
----
-
-# CocoIndex Skill
-
-## When to Use CocoIndex
-
-Use CocoIndex tools and commands when you need to:
-
-1. **Search indexed project content** — use `cocoindex_search` instead of `content_search` or `ctx_search`
-2. **Trigger re-indexing** — use `/unipi:cocoindex-update` after significant code changes
-3. **Initialize indexing** — use `/unipi:cocoindex-init` for new projects
-
-## Key Differences from Old FTS5 Content Store
-
-| Aspect | Old (FTS5) | New (CocoIndex) |
-|--------|-----------|-----------------|
-| Chunking | Heading/paragraph split | AST-aware code, recursive text |
-| Search | BM25 + trigram fuzzy | Semantic vector + full-text |
-| Incremental | Full re-index every time | Delta-only (changed files) |
-| Scale | Small corpus | Multi-GiB, parallel |
-| Store | SQLite FTS5 | LanceDB |
-
-## Tools
-
-### `cocoindex_search`
-Search indexed content. It uses semantic vector search when the LanceDB table has vectors, LanceDB full-text search when an inverted index exists, and a lexical fallback for older text-only indexes.
-
-```
-cocoindex_search({ query: "how authentication works", limit: 10 })
-```
-
-Returns results with `title`, `content`, `source`, `rank`, `contentType`, and `matchLayer`.
-
-### `cocoindex_status`
-Check indexing status — pipeline configured, last run, doc count, CLI availability.
-
-```
-cocoindex_status({})
-```
-
-## Commands
-
-| Command | Description |
-|---------|-------------|
-| `/unipi:cocoindex-update` | Run `cocoindex update` on current project |
-| `/unipi:cocoindex-status` | Show indexing status |
-| `/unipi:cocoindex-init` | Scaffold a default pipeline |
-| `/unipi:cocoindex-search <query>` | Search indexed codebase semantically |
-| `/unipi:cocoindex-settings` | Show configuration |
-
-## Prerequisites
-
-1. **Python 3.10+** with `cocoindex` installed:
-   ```bash
-   pip install cocoindex
-   pip install 'cocoindex[lancedb]'
-   ```
-
-2. **Pipeline initialized** — run `/unipi:cocoindex-init` once per project
-
-3. **Embedding config** — CocoIndex reuses the memory package's embedding settings:
-   - API key from `~/.unipi/memory/config.json`
-   - Same model and dimensions for cross-system search
-
-## Architecture
-
-```
-Project files → LocalFile source → SplitRecursively → EmbedText → LanceDB
-                                                                              ↓
-Agent query ──────────────────────────────→ vector search → ranked results
-```
-
-- Pipeline defined in `.unipi/cocoindex/main.py` (auto-generated, customizable)
-- Data stored in `.unipi/cocoindex/.lancedb/`
-- Search queries LanceDB directly via Node.js SDK (no CLI round-trip)
-
-## Troubleshooting
-
-| Issue | Fix |
-|-------|-----|
-| "CLI not found" | `pip install cocoindex` |
-| "Pipeline not initialized" | `/unipi:cocoindex-init` |
-| "Search unavailable" | `npm install @lancedb/lancedb` |
-| "No results" | Run `/unipi:cocoindex-update` first |
-| Embedding errors | Check `~/.unipi/memory/config.json` API key |

package/packages/cocoindex/tools.ts

@@ -1,157 +0,0 @@
-/**
- * tools.ts — CocoIndex tool registration
- *
- * Exposes cocoindex operations as Pi agent tools:
- * - cocoindex_search: Search indexed content
- * - cocoindex_status: Show indexing status
- */
-
-import { Type } from "typebox";
-import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
-import { COCOINDEX_PACKAGE_SPEC, COCOINDEX_TOOLS } from "@pi-unipi/core";
-import * as bridge from "./bridge.js";
-
-export interface CocoindexToolDeps {
-  getProjectDir(ctx: ExtensionContext): string;
-}
-
-// ─────────────────────────────────────────────────────────
-// Schemas
-// ─────────────────────────────────────────────────────────
-
-export const MAX_SEARCH_RESULTS = 50;
-
-export function normalizeSearchPage(limit?: number, offset?: number): { limit: number; offset: number } {
-  const requestedLimit = Number.isFinite(limit) ? Math.floor(limit!) : 10;
-  const requestedOffset = Number.isFinite(offset) ? Math.floor(offset!) : 0;
-  return {
-    limit: Math.min(MAX_SEARCH_RESULTS, Math.max(1, requestedLimit)),
-    offset: Math.max(0, requestedOffset),
-  };
-}
-
-const SearchParams = Type.Object({
-  query: Type.String({ description: "Search query against indexed content" }),
-  limit: Type.Optional(Type.Number({
-    description: `Max results (default 10, hard cap ${MAX_SEARCH_RESULTS})`,
-    minimum: 1,
-    maximum: MAX_SEARCH_RESULTS,
-  })),
-  offset: Type.Optional(Type.Number({ description: "Pagination offset", minimum: 0 })),
-});
-
-const StatusParams = Type.Object({});
-
-// ─────────────────────────────────────────────────────────
-// Helpers
-// ─────────────────────────────────────────────────────────
-
-function textResult(text: string, details?: Record<string, unknown>): any {
-  return {
-    content: [{ type: "text", text }],
-    details,
-  };
-}
-
-// ─────────────────────────────────────────────────────────
-// Registration
-// ─────────────────────────────────────────────────────────
-
-export function registerCocoindexTools(pi: ExtensionAPI, deps: CocoindexToolDeps): void {
-  // cocoindex_search — search indexed content via LanceDB
-  pi.registerTool({
-    name: COCOINDEX_TOOLS.SEARCH,
-    label: "CocoIndex Search",
-    description:
-      "Search indexed content using semantic vector search when available, with full-text/lexical fallbacks. " +
-      "Diagnostic/search only: this tool never installs CocoIndex. " +
-      "Use /unipi:cocoindex-init to set up/install, then /unipi:cocoindex-update to index.",
-    parameters: SearchParams,
-    async execute(
-      _toolCallId: string,
-      params: any,
-      _signal: AbortSignal | undefined,
-      _onUpdate: unknown,
-      ctx: ExtensionContext,
-    ): Promise<any> {
-      try {
-        const available = await bridge.isAvailable();
-        if (!available) {
-          return textResult(
-            "Search Unavailable: CocoIndex CLI is not installed. " +
-            "Run /unipi:cocoindex-init for guided install, or manually run " +
-            `uv tool install '${COCOINDEX_PACKAGE_SPEC}'.`,
-            { cliAvailable: false },
-          );
-        }
-
-        // Clamp in execution as well as schema validation: Pi extensions may
-        // mutate tool inputs after validation and custom hosts may skip it.
-        const { limit, offset } = normalizeSearchPage(params.limit, params.offset);
-        const results = await bridge.search(deps.getProjectDir(ctx), params.query, {
-          limit,
-          offset,
-        });
-
-        if (results.length === 0) {
-          return textResult(
-            `No results for "${params.query}" in the current CocoIndex data. ` +
-            "If this seems wrong, run /unipi:cocoindex-status to confirm the pipeline has data, then /unipi:cocoindex-update to refresh it.",
-          );
-        }
-
-        const lines = results.map(
-          (r, i) =>
-            `[${i + 1}] ${r.title} (${r.matchLayer}, rank: ${r.rank.toFixed(3)})\n${r.content.slice(0, 300)}`,
-        );
-        return textResult(
-          `Found ${results.length} results for "${params.query}":\n\n${lines.join("\n\n")}`,
-          // Avoid duplicating full result content in model-visible details.
-          { count: results.length, query: params.query, limit, offset },
-        );
-      } catch (err) {
-        return textResult(`CocoIndex search error: ${err}`, { error: true });
-      }
-    },
-  } as any);
-
-  // cocoindex_status — show indexing status
-  pi.registerTool({
-    name: COCOINDEX_TOOLS.STATUS,
-    label: "CocoIndex Status",
-    description: "Check CocoIndex indexing status. Diagnostic only; use commands for interactive install/update.",
-    parameters: StatusParams,
-    async execute(
-      _toolCallId: string,
-      _params: Record<string, never>,
-      _signal: AbortSignal | undefined,
-      _onUpdate: unknown,
-      ctx: ExtensionContext,
-    ): Promise<any> {
-      try {
-        const info = await bridge.status(deps.getProjectDir(ctx));
-        const lines = [
-          `📦 CocoIndex Status`,
-          `CLI available: ${info.cliAvailable ? "✅" : "❌"}`,
-          `Pipeline configured: ${info.pipelineConfigured ? "✅" : "❌"}`,
-          `Target store: ${info.targetStore}`,
-          `Indexed: ${info.indexed ? "✅" : "— (no data)"}`,
-          `Doc count: ${info.docCount}`,
-          `Last run: ${info.lastRun ?? "never"}`,
-        ];
-        if (!info.cliAvailable) {
-          lines.push(
-            "",
-            "Install guidance:",
-            "  • Run /unipi:cocoindex-init for guided install.",
-            `  • Manual: uv tool install '${COCOINDEX_PACKAGE_SPEC}'`,
-            "  • If uv is missing and mise is available: mise use -g uv@latest",
-          );
-        }
-        return textResult(lines.join("\n"), info as unknown as Record<string, unknown>);
-      } catch (err) {
-        return textResult(`CocoIndex status error: ${err}`, { error: true });
-      }
-    },
-  } as any);
-}

package/packages/compactor/src/display/diff-renderer.ts

@@ -1,281 +0,0 @@
-/**
- * Diff rendering engine — LCS-based diff with 3 layouts, 3 indicators,
- * syntax highlighting, and Nerd Font detection
- */
-
-import { visibleWidth, truncateToWidth } from "@earendil-works/pi-tui";
-
-export type DiffLayout = "auto" | "split" | "unified";
-export type DiffIndicator = "bars" | "classic" | "nerd" | "none";
-
-// --- Nerd Font Detection ---
-
-let nerdFontDetected: boolean | null = null;
-
-/** Detect if terminal supports Nerd Font icons */
-export function detectNerdFont(): boolean {
-  if (nerdFontDetected !== null) return nerdFontDetected;
-  // Check common Nerd Font env vars or terminal emulators
-  const term = process.env.TERM_PROGRAM ?? "";
-  const termFont = process.env.TERM_FONT ?? "";
-  nerdFontDetected =
-    termFont.toLowerCase().includes("nerd") ||
-    process.env.NERD_FONT === "1" ||
-    term === "WezTerm" ||
-    term === "iTerm.app" ||
-    (process.env.TERMINAL_EMULATOR ?? "").includes("JetBrains") ||
-    false;
-  return nerdFontDetected;
-}
-
-/** Nerd Font indicator chars */
-const NERD_INDICATORS = {
-  add: "\uf055 ",   // nf-fa-plus_circle
-  remove: "\uf056 ", // nf-fa-minus_circle
-  same: "  ",
-} as const;
-
-// --- Syntax Highlighting ---
-
-const KEYWORDS: Record<string, Set<string>> = {
-  js: new Set(["const", "let", "var", "function", "return", "if", "else", "for", "while", "class", "import", "export", "from", "async", "await", "try", "catch", "throw", "new", "this", "typeof", "instanceof", "in", "of", "switch", "case", "break", "continue", "default", "yield", "void", "delete", "null", "undefined", "true", "false"]),
-  py: new Set(["def", "class", "import", "from", "return", "if", "elif", "else", "for", "while", "try", "except", "finally", "raise", "with", "as", "yield", "lambda", "pass", "break", "continue", "and", "or", "not", "in", "is", "None", "True", "False", "self", "async", "await"]),
-  ts: new Set(["const", "let", "var", "function", "return", "if", "else", "for", "while", "class", "import", "export", "from", "async", "await", "try", "catch", "throw", "new", "this", "typeof", "instanceof", "interface", "type", "enum", "namespace", "module", "declare", "implements", "extends", "public", "private", "protected", "readonly", "static", "abstract", "override", "keyof", "infer", "never", "unknown", "any", "void", "string", "number", "boolean", "null", "undefined", "true", "false"]),
-  sh: new Set(["if", "then", "else", "elif", "fi", "for", "while", "do", "done", "case", "esac", "function", "return", "local", "export", "readonly", "declare", "unset", "shift", "source", "exit", "echo", "printf", "read", "test", "true", "false"]),
-};
-
-/** Apply basic syntax highlighting to a line */
-function highlightLine(line: string, lang?: string): string {
-  if (!lang) return line;
-  const keywords = KEYWORDS[lang] ?? KEYWORDS.js;
-  // Highlight keywords (simple word boundary match)
-  return line.replace(/\b([a-zA-Z_]\w*)\b/g, (match) => {
-    if (keywords.has(match)) return `\x1b[34m${match}\x1b[0m`; // blue
-    return match;
-  });
-}
-
-/** Detect language from file extension or content */
-function detectLanguage(filePath?: string, content?: string): string | undefined {
-  if (filePath) {
-    const ext = filePath.split(".").pop()?.toLowerCase();
-    const extMap: Record<string, string> = {
-      js: "js", mjs: "js", cjs: "js", jsx: "js",
-      ts: "ts", mts: "ts", cts: "ts", tsx: "ts",
-      py: "py", pyw: "py",
-      sh: "sh", bash: "sh", zsh: "sh",
-    };
-    if (ext && extMap[ext]) return extMap[ext];
-  }
-  if (content) {
-    if (content.includes("def ") || content.includes("import ")) return "py";
-    if (content.includes("function ") || content.includes("const ")) return "js";
-    if (content.includes("#!/bin/")) return "sh";
-  }
-  return undefined;
-}
-
-interface DiffLine {
-  type: "same" | "add" | "remove";
-  text: string;
-}
-
-function lcs<T>(a: T[], b: T[]): T[] {
-  const m = a.length;
-  const n = b.length;
-  const dp: number[][] = Array.from({ length: m + 1 }, () => Array(n + 1).fill(0));
-
-  for (let i = 1; i <= m; i++) {
-    for (let j = 1; j <= n; j++) {
-      if (a[i - 1] === b[j - 1]) {
-        dp[i][j] = dp[i - 1][j - 1] + 1;
-      } else {
-        dp[i][j] = Math.max(dp[i - 1][j], dp[i][j - 1]);
-      }
-    }
-  }
-
-  const result: T[] = [];
-  let i = m, j = n;
-  while (i > 0 && j > 0) {
-    if (a[i - 1] === b[j - 1]) {
-      result.unshift(a[i - 1]);
-      i--;
-      j--;
-    } else if (dp[i - 1][j] > dp[i][j - 1]) {
-      i--;
-    } else {
-      j--;
-    }
-  }
-
-  return result;
-}
-
-function computeDiff(before: string[], after: string[]): DiffLine[] {
-  const common = lcs(before, after);
-  const result: DiffLine[] = [];
-  let i = 0, j = 0, k = 0;
-
-  while (i < before.length || j < after.length) {
-    if (k < common.length && before[i] === common[k] && after[j] === common[k]) {
-      result.push({ type: "same", text: after[j] });
-      i++;
-      j++;
-      k++;
-    } else if (i < before.length && (k >= common.length || before[i] !== common[k])) {
-      result.push({ type: "remove", text: before[i] });
-      i++;
-    } else if (j < after.length && (k >= common.length || after[j] !== common[k])) {
-      result.push({ type: "add", text: after[j] });
-      j++;
-    } else {
-      break;
-    }
-  }
-
-  return result;
-}
-
-function indicatorChar(type: DiffLine["type"], style: DiffIndicator): string {
-  if (style === "none") return "  ";
-  if (style === "nerd") {
-    if (type === "add") return `\x1b[32m${NERD_INDICATORS.add}\x1b[0m`;
-    if (type === "remove") return `\x1b[31m${NERD_INDICATORS.remove}\x1b[0m`;
-    return NERD_INDICATORS.same;
-  }
-  if (style === "bars") {
-    if (type === "add") return `\x1b[32m│ \x1b[0m`;
-    if (type === "remove") return `\x1b[31m│ \x1b[0m`;
-    return "  ";
-  }
-  return type === "add" ? "+ " : type === "remove" ? "- " : "  ";
-}
-
-function renderUnified(
-  diff: DiffLine[],
-  indicator: DiffIndicator,
-  maxWidth?: number,
-): string {
-  return diff.map((line) => {
-    const prefix = indicator === "bars"
-      ? (line.type === "add" ? "│ " : line.type === "remove" ? "│ " : "  ")
-      : indicatorChar(line.type, indicator);
-    const rendered = prefix + line.text;
-    if (maxWidth && visibleWidth(rendered) > maxWidth) {
-      return truncateToWidth(rendered, maxWidth, "…");
-    }
-    return rendered;
-  }).join("\n");
-}
-
-function renderSplit(
-  diff: DiffLine[],
-  indicator: DiffIndicator,
-  maxW?: number,
-): string {
-  const left: string[] = [];
-  const right: string[] = [];
-
-  for (const line of diff) {
-    if (line.type === "same") {
-      left.push("  " + line.text);
-      right.push("  " + line.text);
-    } else if (line.type === "remove") {
-      left.push(indicatorChar("remove", indicator) + line.text);
-      right.push("");
-    } else if (line.type === "add") {
-      left.push("");
-      right.push(indicatorChar("add", indicator) + line.text);
-    }
-  }
-
-  const halfW = maxW ? Math.floor(maxW / 2) - 2 : 40;
-  const colW = Math.max(
-    ...left.map((l) => visibleWidth(l)),
-    ...right.map((l) => visibleWidth(l)),
-    Math.min(halfW, 40),
-  );
-  const result: string[] = [];
-  for (let i = 0; i < left.length; i++) {
-    const lTrunc = visibleWidth(left[i]) > colW
-      ? truncateToWidth(left[i], colW, "…")
-      : left[i].padEnd(colW);
-    const sep = left[i] && right[i] ? " │ " : "   ";
-    let rLine = right[i];
-    if (maxW && visibleWidth(lTrunc + sep + rLine) > maxW) {
-      const rBudget = maxW - visibleWidth(lTrunc + sep);
-      rLine = truncateToWidth(rLine, Math.max(1, rBudget), "…");
-    }
-    result.push(lTrunc + sep + rLine);
-  }
-
-  return result.join("\n");
-}
-
-export function renderDiff(
-  before: string,
-  after: string,
-  opts?: { layout?: DiffLayout; indicator?: DiffIndicator; maxWidth?: number; filePath?: string; highlight?: boolean },
-): string {
-  const layout = opts?.layout ?? "auto";
-  let indicator = opts?.indicator ?? "bars";
-  const maxWidth = opts?.maxWidth ?? 120;
-  const doHighlight = opts?.highlight ?? true;
-
-  // Auto-detect Nerd Font for indicator selection
-  if (indicator === "bars" && detectNerdFont()) {
-    indicator = "nerd";
-  }
-
-  const beforeLines = before.split("\n");
-  const afterLines = after.split("\n");
-  const diff = computeDiff(beforeLines, afterLines);
-
-  const effectiveLayout = layout === "auto"
-    ? (maxWidth >= 100 ? "split" : "unified")
-    : layout;
-
-  let effectiveIndicator = indicator;
-  // Auto mode: use classic indicator for unified to keep output clean
-  if (layout === "auto" && effectiveLayout === "unified" && indicator !== "nerd") {
-    effectiveIndicator = "classic";
-  }
-
-  // Apply syntax highlighting if enabled
-  let highlightedDiff = diff;
-  if (doHighlight) {
-    const lang = detectLanguage(opts?.filePath, after);
-    if (lang) {
-      highlightedDiff = diff.map((line) => ({
-        ...line,
-        text: highlightLine(line.text, lang),
-      }));
-    }
-  }
-
-  if (effectiveLayout === "split") {
-    return renderSplit(highlightedDiff, effectiveIndicator, maxWidth);
-  }
-
-  return renderUnified(highlightedDiff, effectiveIndicator, maxWidth);
-}
-
-export function renderEditDiffResult(
-  previousContent: string,
-  newContent: string,
-  opts?: { layout?: DiffLayout; indicator?: DiffIndicator; maxWidth?: number },
-): string {
-  return renderDiff(previousContent, newContent, opts);
-}
-
-export function renderWriteDiffResult(
-  previousContent: string | undefined,
-  newContent: string,
-  opts?: { layout?: DiffLayout; indicator?: DiffIndicator; maxWidth?: number },
-): string {
-  if (!previousContent) {
-    return "[New file created]\n" + newContent.split("\n").map((l) => "+ " + l).join("\n");
-  }
-  return renderDiff(previousContent, newContent, opts);
-}

package/packages/compactor/src/display/line-width-safety.ts

@@ -1,28 +0,0 @@
-/**
- * Line width safety — width clamping with collapsed hints
- *
- * Uses ANSI-aware visibleWidth measurement from pi-tui to properly
- * handle lines containing escape codes. Falls back to raw-length
- * measurement when pi-tui is unavailable.
- */
-
-import { visibleWidth, truncateToWidth } from "@earendil-works/pi-tui";
-
-/**
- * Clamp each line to maxWidth visible columns.
- * Uses pi-tui's visibleWidth() for ANSI-aware measurement and
- * truncateToWidth() for ANSI-safe truncation.
- */
-export function clampLineWidth(lines: string[], maxWidth: number): string[] {
-  return lines.map((line) => {
-    const vw = visibleWidth(line);
-    if (vw <= maxWidth) return line;
-    return truncateToWidth(line, maxWidth, "…");
-  });
-}
-
-export function collapseHint(originalCount: number, shownCount: number): string {
-  const omitted = originalCount - shownCount;
-  if (omitted <= 0) return "";
-  return `...(${omitted} more lines)...`;
-}

package/packages/compactor/src/display/render-utils.ts

@@ -1,52 +0,0 @@
-/**
- * Shared display rendering utilities
- */
-
-export function splitLines(text: string): string[] {
-  return text.split(/\r?\n/);
-}
-
-export function countNonEmptyLines(text: string): number {
-  return splitLines(text).filter((l) => l.trim()).length;
-}
-
-export function compactOutputLines(text: string, maxLines: number): string {
-  const lines = splitLines(text);
-  if (lines.length <= maxLines) return text;
-  const omitted = lines.length - maxLines;
-  return `...(${omitted} lines omitted)...\n${lines.slice(-maxLines).join("\n")}`;
-}
-
-export function previewLines(text: string, lines: number): string {
-  const all = splitLines(text);
-  if (all.length <= lines) return text;
-  return all.slice(0, lines).join("\n") + `\n...(${all.length - lines} more lines)`;
-}
-
-export function pluralize(count: number, singular: string, plural?: string): string {
-  return count === 1 ? `${count} ${singular}` : `${count} ${plural ?? singular + "s"}`;
-}
-
-export function shortenPath(path: string, maxLen: number = 60): string {
-  if (path.length <= maxLen) return path;
-  const parts = path.split("/");
-  if (parts.length <= 2) return "..." + path.slice(-(maxLen - 3));
-  return parts[0] + "/.../" + parts.slice(-2).join("/");
-}
-
-export function extractTextOutput(result: any): string {
-  if (typeof result === "string") return result;
-  if (result?.output) return String(result.output);
-  if (result?.stdout) return String(result.stdout);
-  return "";
-}
-
-export function isLikelyQuietCommand(command: string): boolean {
-  const quietPatterns = [/^\s*cd\s/, /^\s*mkdir\s+-p/, /^\s*touch\s/, /^\s*rm\s+/];
-  return quietPatterns.some((re) => re.test(command));
-}
-
-export function sanitizeAnsiForThemedOutput(text: string): string {
-  // Strip ANSI escape sequences for clean themed rendering
-  return text.replace(/\x1b\[[0-9;]*m/g, "");
-}

package/packages/compactor/src/display/thinking-label.ts

@@ -1,18 +0,0 @@
-/**
- * Thinking labels during streaming
- */
-
-export function formatThinkingLabel(text: string, opts?: { prefix?: string }): string {
-  const prefix = opts?.prefix ?? "🤔";
-  const lines = text.split("\n");
-  if (lines.length === 1) return `${prefix} ${lines[0]}`;
-  return `${prefix} Thinking...\n${text}`;
-}
-
-export function sanitizeThinkingArtifacts(text: string): string {
-  // Remove thinking blocks from context before LLM turn
-  return text
-    .replace(/<thinking>[\s\S]*?<\/thinking>/g, "")
-    .replace(/\[thinking\][\s\S]*?\[\/thinking\]/g, "")
-    .trim();
-}