pi-orchestrator-config 4.1.5

package/extensions/orchestrator/memory-tree.ts

@@ -0,0 +1,212 @@
+/**
+ * Memory Tree — hierarchical topic-based memory organization.
+ *
+ * Organizes memory entries into topic files under .pi/memory/topics/.
+ * Each topic file is a Markdown chunk limited to ~3000 tokens.
+ * Topics have hotness scores based on reinforcement frequency.
+ * The situation report pulls from hot topics first.
+ *
+ * Architecture inspired by OpenHuman (https://github.com/tinyhumansai/openhuman).
+ * Clean-room TypeScript implementation under MIT — not a code translation.
+ */
+
+import { existsSync, readFileSync, writeFileSync, readdirSync, mkdirSync, unlinkSync } from "node:fs";
+import { join } from "node:path";
+import {
+  type MemoryCategory,
+  loadScores,
+  entryHash,
+} from "./memory-scoring.js";
+
+// ── Constants ──────────────────────────────────────────────────────────────
+
+/** Max chars per topic file (~3000 tokens × 4 chars/token) */
+export const MAX_TOPIC_CHARS = 12000;
+
+/** Topic mapping: which categories go into which topic files */
+export const CATEGORY_TO_TOPIC: Record<MemoryCategory, string> = {
+  preference: "preferences",
+  lesson: "lessons",
+  pattern: "patterns",
+  decision: "decisions",
+  done: "completions",
+  mistake: "mistakes",
+};
+
+/** How old a topic's newest entry must be (relative to half-life) before archival */
+const ARCHIVAL_MULTIPLIER = 2;
+
+/** Half-lives in ms for archival check */
+const HALF_LIVES_MS: Record<string, number> = {
+  preferences: 90 * 86400 * 1000,
+  lessons: 60 * 86400 * 1000,
+  patterns: 30 * 86400 * 1000,
+  decisions: 30 * 86400 * 1000,
+  completions: 14 * 86400 * 1000,
+  mistakes: 14 * 86400 * 1000,
+};
+
+// ── Types ──────────────────────────────────────────────────────────────────
+
+export interface TopicInfo {
+  name: string;
+  path: string;
+  entryCount: number;
+  hotness: number;
+  newestEntry: string; // ISO date
+  chars: number;
+}
+
+// ── Topic Directory ────────────────────────────────────────────────────────
+
+function getTopicsDir(cwd: string): string {
+  return join(cwd, ".pi", "memory", "topics");
+}
+
+function ensureTopicsDir(cwd: string): string {
+  const dir = getTopicsDir(cwd);
+  if (!existsSync(dir)) {
+    mkdirSync(dir, { recursive: true });
+  }
+  return dir;
+}
+
+// ── Topic File I/O ─────────────────────────────────────────────────────────
+
+interface TopicFile {
+  entries: { text: string; category: MemoryCategory; pinned: boolean }[];
+}
+
+function readTopicFile(path: string): TopicFile {
+  if (!existsSync(path)) return { entries: [] };
+  try {
+    const content = readFileSync(path, "utf-8");
+    const entries: TopicFile["entries"] = [];
+    for (const line of content.split("\n")) {
+      const match = line.match(/^- \[(preference|lesson|pattern|decision|done|mistake)\] (.+)$/);
+      if (match) {
+        // Strip *(pinned)* and *(enforced)* tags from text (may have duplicates from legacy data)
+        const rawText = match[2]!.replace(/\s*\*\(pinned\)\*/g, "").replace(/\s*\*\(enforced\)\*/g, "").trim();
+        entries.push({
+          text: rawText,
+          category: match[1] as MemoryCategory,
+          pinned: line.includes("*(pinned)*"),
+        });
+      }
+    }
+    return { entries };
+  } catch {
+    return { entries: [] };
+  }
+}
+
+function writeTopicFile(
+  path: string,
+  topicName: string,
+  entries: TopicFile["entries"],
+): void {
+  const header = `# ${topicName.charAt(0).toUpperCase() + topicName.slice(1)}\n\n`;
+  const lines = entries.map((e) => {
+    const pinTag = e.pinned ? " *(pinned)*" : "";
+    return `- [${e.category}] ${e.text}${pinTag}`;
+  });
+  const content = header + lines.join("\n") + "\n";
+
+  // Enforce token limit — truncate if too long
+  if (content.length > MAX_TOPIC_CHARS) {
+    const truncated = content.slice(0, MAX_TOPIC_CHARS);
+    const lastNewline = truncated.lastIndexOf("\n");
+    writeFileSync(path, truncated.slice(0, lastNewline + 1), "utf-8");
+  } else {
+    writeFileSync(path, content, "utf-8");
+  }
+}
+
+// ── Archival ───────────────────────────────────────────────────────────────
+
+function archiveColdTopics(topicsDir: string, topics: TopicInfo[], now: number): void {
+  for (const topic of topics) {
+    const halfLifeMs = HALF_LIVES_MS[topic.name] || 30 * 86400 * 1000;
+    const threshold = halfLifeMs * ARCHIVAL_MULTIPLIER;
+    const newestMs = new Date(topic.newestEntry).getTime();
+    const age = now - newestMs;
+
+    if (age > threshold && topic.entryCount > 0) {
+      // Check if all entries are non-pinned before archiving
+      const topicFile = readTopicFile(topic.path);
+      const hasPinned = topicFile.entries.some((e) => e.pinned);
+      if (!hasPinned) {
+        try {
+          unlinkSync(topic.path);
+        } catch (e: any) { console.debug("[memory-tree] archive topic delete failed:", e?.message || e); }
+      }
+    }
+  }
+}
+
+// ── Read All Topic Entries ──────────────────────────────────────────────────
+
+/**
+ * Read all entries from all topic files.
+ * This is the primary read path — topics are the source of truth.
+ */
+export function readAllTopicEntries(cwd: string): { text: string; category: MemoryCategory; pinned: boolean }[] {
+  const topicsDir = getTopicsDir(cwd);
+  if (!existsSync(topicsDir)) return [];
+
+  const all: { text: string; category: MemoryCategory; pinned: boolean }[] = [];
+  try {
+    const files = readdirSync(topicsDir).filter((f) => f.endsWith(".md"));
+    for (const file of files) {
+      const topicFile = readTopicFile(join(topicsDir, file));
+      all.push(...topicFile.entries);
+    }
+  } catch (e: any) { console.debug("[memory-tree] read topic entries failed:", e?.message || e); }
+  return all;
+}
+
+// ── List Topics ────────────────────────────────────────────────────────────
+
+/**
+ * List all topic files with their info.
+ */
+export function listTopics(cwd: string): TopicInfo[] {
+  const topicsDir = getTopicsDir(cwd);
+  if (!existsSync(topicsDir)) return [];
+
+  const scores = loadScores(cwd);
+  const infos: TopicInfo[] = [];
+
+  try {
+    const files = readdirSync(topicsDir).filter((f) => f.endsWith(".md"));
+    for (const file of files) {
+      const path = join(topicsDir, file);
+      const topicFile = readTopicFile(path);
+      const topicName = file.replace(/\.md$/, "");
+
+      let hotness = 0;
+      let newestDate = 0;
+      for (const entry of topicFile.entries) {
+        const line = `- [${entry.category}] ${entry.text}`;
+        const hash = entryHash(line);
+        const scored = scores.entries[hash];
+        if (scored) {
+          hotness += scored.score;
+          const reinforced = new Date(scored.lastReinforced).getTime();
+          if (reinforced > newestDate) newestDate = reinforced;
+        }
+      }
+
+      infos.push({
+        name: topicName,
+        path,
+        entryCount: topicFile.entries.length,
+        hotness,
+        newestEntry: newestDate ? new Date(newestDate).toISOString() : "",
+        chars: readFileSync(path, "utf-8").length,
+      });
+    }
+  } catch (e: any) { console.debug("[memory-tree] list topics failed:", e?.message || e); }
+
+  return infos.sort((a, b) => b.hotness - a.hotness);
+}

package/extensions/orchestrator/nvim.ts

@@ -0,0 +1,169 @@
+/**
+ * Neovim integration — communicate with the parent nvim instance via RPC.
+ * Only registers when running inside nvim (NVIM env var is set).
+ */
+
+import { execFileSync } from "node:child_process";
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { runGit } from "./git-helpers.js";
+import { getProjectTmpDir } from "./utils.js";
+
+const NVIM_SOCKET = process.env.NVIM;
+
+/**
+ * Check if we're running inside a neovim terminal.
+ */
+function isInsideNvim(): boolean {
+  return !!NVIM_SOCKET;
+}
+
+/**
+ * Execute a lua file in the parent nvim instance via --remote-expr.
+ * Returns the JSON-parsed result, or null on failure.
+ */
+function nvimExecLua(luaCode: string, cwd?: string): any | null {
+  if (!NVIM_SOCKET) return null;
+
+  const tmpFile = path.join(getProjectTmpDir(cwd || process.cwd()), `nvim-${process.pid}-${Date.now()}.lua`);
+  try {
+    fs.writeFileSync(tmpFile, luaCode, "utf-8");
+    const result = execFileSync(
+      "nvim",
+      ["--server", NVIM_SOCKET, "--remote-expr", `luaeval("dofile('${tmpFile.replace(/'/g, "\\'")}')")` ],
+      { timeout: 5000, stdio: ["pipe", "pipe", "pipe"] },
+    ).toString().trim();
+
+    if (!result) return null;
+    return JSON.parse(result);
+  } catch {
+    return null;
+  } finally {
+    try { fs.unlinkSync(tmpFile); } catch {}
+  }
+}
+
+/**
+ * Send a quickfix list to nvim and open the quickfix window.
+ * Each entry: { filename, lnum?, col?, text }
+ */
+function nvimSetQuickfix(entries: Array<{ filename: string; lnum?: number; col?: number; text?: string }>, title?: string, cwd?: string): boolean {
+  if (!NVIM_SOCKET || entries.length === 0) return false;
+
+  const dataFile = path.join(getProjectTmpDir(cwd || process.cwd()), `nvim-qf-${process.pid}-${Date.now()}.json`);
+  try {
+    fs.writeFileSync(dataFile, JSON.stringify(entries), "utf-8");
+
+    const titleLine = title ? `vim.fn.setqflist({}, "a", {title = "${title.replace(/\\/g, '\\\\').replace(/"/g, '\\"')}"})` : "";
+    const safeDataFile = dataFile.replace(/"/g, '\\"');
+    const lua = `
+local f = io.open("${safeDataFile}", "r")
+if not f then return vim.fn.json_encode({status = "error", message = "no data file"}) end
+local raw = f:read("*a")
+f:close()
+os.remove("${safeDataFile}")
+local entries = vim.fn.json_decode(raw)
+local items = {}
+for _, e in ipairs(entries) do
+  table.insert(items, {
+    filename = e.filename,
+    lnum = e.lnum or 1,
+    col = e.col or 1,
+    text = e.text or "",
+  })
+end
+vim.fn.setqflist(items)
+${titleLine}
+vim.cmd("copen")
+return vim.fn.json_encode({status = "ok", count = #items})
+`;
+
+    const result = nvimExecLua(lua, cwd);
+    // Clean up data file if lua didn't remove it (nvim unreachable)
+    if (result?.status !== "ok") {
+      try { fs.unlinkSync(dataFile); } catch {}
+    }
+    return result?.status === "ok";
+  } catch {
+    try { fs.unlinkSync(dataFile); } catch {}
+    return false;
+  }
+}
+
+/**
+ * Get git changed files relative to origin/main (or HEAD if on main).
+ */
+function getChangedFiles(cwd: string): Array<{ filename: string; status: string }> {
+  const branchResult = runGit(["rev-parse", "--abbrev-ref", "HEAD"], cwd);
+  if (branchResult.code !== 0) return [];
+  const branch = branchResult.stdout?.trim() || "";
+
+  const seen = new Set<string>();
+  const files: Array<{ filename: string; status: string }> = [];
+
+  const parseDiffOutput = (output: string) => {
+    for (const line of output.trim().split("\n")) {
+      const parts = line.split("\t");
+      if (parts.length >= 2) {
+        const statusCode = parts[0].charAt(0);
+        const filename = parts[parts.length - 1];
+        if (seen.has(filename)) continue;
+        seen.add(filename);
+        const statusMap: Record<string, string> = {
+          M: "modified", A: "added", D: "deleted", R: "renamed", C: "copied",
+        };
+        files.push({ filename, status: statusMap[statusCode] || statusCode });
+      }
+    }
+  };
+
+  if (branch === "main" || branch === "master") {
+    const result = runGit(["diff", "--name-status", "HEAD"], cwd);
+    if (result.code === 0 && result.stdout?.trim()) parseDiffOutput(result.stdout);
+  } else {
+    // Committed changes vs default branch
+    const hasMain = runGit(["rev-parse", "--verify", "origin/main"], cwd).code === 0;
+    const base = hasMain ? "origin/main" : "origin/master";
+    const committed = runGit(["diff", "--name-status", `${base}...HEAD`], cwd);
+    if (committed.code === 0 && committed.stdout?.trim()) parseDiffOutput(committed.stdout);
+    // Uncommitted changes (working tree + staged)
+    const uncommitted = runGit(["diff", "--name-status", "HEAD"], cwd);
+    if (uncommitted.code === 0 && uncommitted.stdout?.trim()) parseDiffOutput(uncommitted.stdout);
+  }
+
+  return files;
+}
+
+export function registerNvim(pi: ExtensionAPI): void {
+  if (!isInsideNvim()) return;
+  if (process.env.PI_SUBAGENT_CHILD === "1") return;
+
+  pi.registerCommand("nvim-changed-files", {
+    description: "Open git changed files in nvim's quickfix list",
+    handler: async (_args, ctx) => {
+      if (!ctx.hasUI) return;
+
+      const files = getChangedFiles(ctx.cwd);
+      if (files.length === 0) {
+        ctx.ui.notify("No changed files found.", "info");
+        return;
+      }
+
+      const entries = files.map(f => ({
+        filename: path.resolve(ctx.cwd, f.filename),
+        lnum: 1,
+        text: f.status,
+      }));
+
+      const ok = nvimSetQuickfix(entries, "pi: changed files", ctx.cwd);
+      if (ok) {
+        ctx.ui.notify(`Sent ${entries.length} changed file(s) to nvim quickfix.`, "info");
+      } else {
+        ctx.ui.notify("Failed to send quickfix to nvim.", "warning");
+      }
+    },
+  });
+
+}

package/extensions/orchestrator/overlay-dashboard-utils.ts

@@ -0,0 +1,25 @@
+/**
+ * Pure overlay dashboard helpers — no TUI deps (unit-testable).
+ */
+
+export type OverlayId = string | number;
+
+export interface OverlaySelection<TId extends OverlayId = OverlayId> {
+  id?: TId;
+  index: number;
+}
+
+export function reconcileSelection<TId extends OverlayId>(
+  selection: OverlaySelection<TId>,
+  items: ReadonlyArray<{ id: TId }>,
+): void {
+  const stableIndex =
+    selection.id !== undefined && selection.id !== null
+      ? items.findIndex((item) => item.id === selection.id)
+      : -1;
+  selection.index =
+    stableIndex >= 0
+      ? stableIndex
+      : Math.min(Math.max(0, selection.index), Math.max(0, items.length - 1));
+  selection.id = items[selection.index]?.id;
+}