@selesai/code 0.13.0 → 0.13.1

package/dist/extensions/pi-hermes-memory/src/store/sqlite-native.ts

@@ -0,0 +1,241 @@
+/**
+ * Shared better-sqlite3 loader with ABI mismatch recovery.
+ *
+ * Pi installs extension deps under ~/.selesai/agent/npm. When the host Node that
+ * runs Pi (e.g. Homebrew) differs from the Node that compiled better-sqlite3,
+ * require() throws NODE_MODULE_VERSION errors. Detect that, attempt one
+ * npm rebuild against the current runtime, and surface a clear recovery path.
+ */
+
+import { createRequire } from "node:module";
+import { spawnSync } from "node:child_process";
+import fs from "node:fs";
+import path from "node:path";
+
+export type BetterSqlite3DatabaseCtor = new (
+  dbPath: string,
+  options?: { readonly?: boolean; fileMustExist?: boolean; timeout?: number },
+) => unknown;
+
+export interface SqliteNativeLoadOptions {
+  /** Override createRequire base URL (tests). */
+  requireFrom?: string | URL;
+  /** Inject require() for tests. */
+  requireImpl?: NodeRequire;
+  /** Inject rebuild runner for tests. */
+  rebuild?: (packageRoot: string) => { ok: boolean; detail: string };
+  /** Force treating the first load failure as rebuild-eligible (tests). */
+  allowRebuild?: boolean;
+}
+
+export class BetterSqlite3LoadError extends Error {
+  readonly code = "BETTER_SQLITE3_LOAD_FAILED";
+  readonly packageRoot: string | null;
+  readonly causeError: unknown;
+
+  constructor(message: string, options: { packageRoot?: string | null; cause?: unknown } = {}) {
+    super(message);
+    this.name = "BetterSqlite3LoadError";
+    this.packageRoot = options.packageRoot ?? null;
+    this.causeError = options.cause;
+  }
+}
+
+const ABI_MISMATCH_RE =
+  /NODE_MODULE_VERSION|was compiled against a different Node\.js version|ERR_DLOPEN_FAILED/i;
+
+/**
+ * True when running under Bun (including the compiled Pi binary).
+ *
+ * Compiled Pi cannot resolve `better-sqlite3` — neither the bare specifier nor
+ * the package's own transitive `require("bindings")` resolve from an on-disk
+ * extension file, so every code path that needs SQLite must route through
+ * `bun:sqlite` instead of loading the native module.
+ */
+export function isBunRuntime(): boolean {
+  return "Bun" in globalThis;
+}
+
+export function isNativeModuleAbiMismatch(error: unknown): boolean {
+  if (!error) return false;
+  const message = error instanceof Error ? error.message : String(error);
+  if (ABI_MISMATCH_RE.test(message)) return true;
+  if (typeof error === "object" && error !== null) {
+    const code = "code" in error ? String((error as { code?: unknown }).code ?? "") : "";
+    if (code === "ERR_DLOPEN_FAILED") return true;
+  }
+  return false;
+}
+
+export function resolveBetterSqlite3PackageRoot(requireImpl: NodeRequire): string | null {
+  try {
+    const entry = requireImpl.resolve("better-sqlite3");
+    let dir = path.dirname(entry);
+    while (true) {
+      const pkgPath = path.join(dir, "package.json");
+      if (fs.existsSync(pkgPath)) {
+        try {
+          const raw = fs.readFileSync(pkgPath, "utf-8");
+          const pkg = JSON.parse(raw) as { name?: unknown };
+          if (pkg && typeof pkg === "object" && pkg.name === "better-sqlite3") return dir;
+        } catch {
+          // keep walking
+        }
+      }
+      const parent = path.dirname(dir);
+      if (parent === dir) break;
+      dir = parent;
+    }
+
+    // Classic layout fallback: .../node_modules/better-sqlite3/<...>
+    const parts = entry.split(path.sep);
+    const idx = parts.lastIndexOf("better-sqlite3");
+    if (idx >= 0) {
+      return parts.slice(0, idx + 1).join(path.sep) || null;
+    }
+    return path.dirname(entry);
+  } catch {
+    return null;
+  }
+}
+function defaultRebuild(packageRoot: string): { ok: boolean; detail: string } {
+  const npmExecPath = typeof process.env.npm_execpath === "string" && process.env.npm_execpath
+    ? process.env.npm_execpath
+    : null;
+
+  const attempts: Array<{ command: string; args: string[]; shell?: boolean }> = [];
+  if (npmExecPath) {
+    attempts.push({ command: process.execPath, args: [npmExecPath, "rebuild", "better-sqlite3"] });
+  }
+  attempts.push({ command: "npm", args: ["rebuild", "better-sqlite3"] });
+
+  const details: string[] = [];
+  for (const attempt of attempts) {
+    const result = spawnSync(attempt.command, attempt.args, {
+      cwd: packageRoot,
+      encoding: "utf-8",
+      env: process.env,
+      timeout: 120_000,
+      shell: attempt.shell ?? false,
+    });
+    if (result.error) {
+      details.push(`${attempt.command}: ${result.error.message}`);
+      continue;
+    }
+    if (result.status === 0) {
+      return { ok: true, detail: (result.stdout || result.stderr || "rebuild ok").trim() };
+    }
+    const output = [result.stdout, result.stderr].filter(Boolean).join("\n").trim();
+    details.push(`${attempt.command} exited ${result.status}${output ? `: ${output}` : ""}`);
+  }
+
+  return { ok: false, detail: details.join(" | ") || "rebuild failed" };
+}
+
+function unwrapModule(mod: { default?: BetterSqlite3DatabaseCtor } | BetterSqlite3DatabaseCtor): BetterSqlite3DatabaseCtor {
+  return (mod as { default?: BetterSqlite3DatabaseCtor }).default ?? (mod as BetterSqlite3DatabaseCtor);
+}
+
+function clearBetterSqlite3RequireCache(requireImpl: NodeRequire, packageRoot: string | null): void {
+  for (const key of Object.keys(requireImpl.cache)) {
+    if (!key.includes(`${path.sep}better-sqlite3${path.sep}`) && !key.endsWith(`${path.sep}better-sqlite3`)) {
+      continue;
+    }
+    if (packageRoot && !key.startsWith(packageRoot)) continue;
+    delete requireImpl.cache[key];
+  }
+}
+
+export function formatBetterSqlite3AbiError(options: {
+  originalError: unknown;
+  packageRoot: string | null;
+  rebuildAttempted: boolean;
+  rebuildDetail?: string;
+}): string {
+  const original = options.originalError instanceof Error
+    ? options.originalError.message
+    : String(options.originalError);
+  const runtime = `Node ${process.version} (NODE_MODULE_VERSION ${process.versions.modules}) via ${process.execPath}`;
+  const location = options.packageRoot ?? "(better-sqlite3 package root unknown)";
+  const rebuildLine = options.rebuildAttempted
+    ? (options.rebuildDetail
+      ? `Automatic rebuild was attempted and failed: ${options.rebuildDetail}`
+      : "Automatic rebuild was attempted and failed.")
+    : "Automatic rebuild was not attempted.";
+
+  return [
+    "pi-hermes-memory could not load the native better-sqlite3 module for this Node runtime.",
+    `Runtime: ${runtime}`,
+    `Module: ${location}`,
+    `Original error: ${original}`,
+    rebuildLine,
+    "Fix: rebuild the extension install against the same Node that runs Pi, then restart Pi:",
+    options.packageRoot
+      ? `  cd "${options.packageRoot}" && npm rebuild better-sqlite3`
+      : "  cd ~/.selesai/agent/npm && npm rebuild better-sqlite3",
+    "If you installed Pi with Homebrew, either rebuild as above after brew Node upgrades, or install Pi with npm so the extension and host share one Node toolchain.",
+  ].join("\n");
+}
+
+/**
+ * Load better-sqlite3, attempting one rebuild on ABI/dlopen mismatch.
+ */
+export function loadBetterSqlite3(options: SqliteNativeLoadOptions = {}): BetterSqlite3DatabaseCtor {
+  const requireImpl = options.requireImpl
+    ?? createRequire(options.requireFrom ?? import.meta.url);
+
+  const loadOnce = (): BetterSqlite3DatabaseCtor => {
+    const mod = requireImpl("better-sqlite3") as { default?: BetterSqlite3DatabaseCtor } | BetterSqlite3DatabaseCtor;
+    return unwrapModule(mod);
+  };
+
+  try {
+    return loadOnce();
+  } catch (firstError) {
+    const packageRoot = resolveBetterSqlite3PackageRoot(requireImpl);
+    const canRebuild = options.allowRebuild ?? isNativeModuleAbiMismatch(firstError);
+    if (!canRebuild || !packageRoot) {
+      if (isNativeModuleAbiMismatch(firstError)) {
+        throw new BetterSqlite3LoadError(
+          formatBetterSqlite3AbiError({
+            originalError: firstError,
+            packageRoot,
+            rebuildAttempted: false,
+          }),
+          { packageRoot, cause: firstError },
+        );
+      }
+      throw firstError;
+    }
+
+    const rebuild = options.rebuild ?? defaultRebuild;
+    const rebuildResult = rebuild(packageRoot);
+    clearBetterSqlite3RequireCache(requireImpl, packageRoot);
+
+    if (rebuildResult.ok) {
+      try {
+        return loadOnce();
+      } catch (secondError) {
+        throw new BetterSqlite3LoadError(
+          formatBetterSqlite3AbiError({
+            originalError: secondError,
+            packageRoot,
+            rebuildAttempted: true,
+            rebuildDetail: rebuildResult.detail,
+          }),
+          { packageRoot, cause: secondError },
+        );
+      }
+    }
+
+    throw new BetterSqlite3LoadError(
+      formatBetterSqlite3AbiError({
+        originalError: firstError,
+        packageRoot,
+        rebuildAttempted: true,
+        rebuildDetail: rebuildResult.detail,
+      }),
+      { packageRoot, cause: firstError },
+    );
+  }
+}

package/dist/extensions/pi-hermes-memory/src/store/standing-instructions.ts

@@ -0,0 +1,247 @@
+/**
+ * Standing instructions — bounded, user-authored directives injected into
+ * every session regardless of memoryMode.
+ *
+ * Why this is a separate store rather than a flag on MEMORY.md / USER.md
+ * (#121): in policy-only mode a persisted constraint only takes effect if the
+ * model decides to call memory_search *before* the action the constraint would
+ * have prevented. For a prohibition that is exactly the moment the model has no
+ * reason to look, so the recall path is structurally unable to enforce it,
+ * independent of model quality. Such constraints have to be unconditionally
+ * present instead.
+ *
+ * Provenance is a property of the storage, not of a flag: background review,
+ * consolidation and the correction detector all write through MemoryStore and
+ * never touch this file, so a model-generated memory has no path into the
+ * always-injected block. Only a direct user edit or /memory-pin can write here.
+ *
+ * The budget is hard and separate from the Markdown stores: a user whose
+ * MEMORY.md + USER.md already run to tens of KB must still be able to pin a
+ * handful of rules without paying for the rest.
+ */
+
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+import {
+  STANDING_MAX_CHARS,
+  STANDING_MAX_ENTRIES,
+} from "../constants.js";
+import { scanContent } from "./content-scanner.js";
+import { withMarkdownMutationLock } from "./markdown-mutation-lock.js";
+
+export interface StandingInstructionResult {
+  success: boolean;
+  error?: string;
+  message?: string;
+  instructions?: string[];
+}
+
+/** What actually reached the prompt, so callers can report truncation loudly. */
+export interface StandingInstructionRender {
+  block: string;
+  injectedCount: number;
+  omittedCount: number;
+}
+
+export class StandingInstructions {
+  private instructions: string[] = [];
+  private loaded = false;
+
+  constructor(
+    private readonly filePath: string,
+    private readonly maxEntries: number = STANDING_MAX_ENTRIES,
+    private readonly maxChars: number = STANDING_MAX_CHARS,
+  ) {}
+
+  getFilePath(): string {
+    return this.filePath;
+  }
+
+  async load(): Promise<void> {
+    try {
+      const raw = await fs.readFile(this.filePath, "utf-8");
+      this.instructions = parseInstructions(raw);
+    } catch (error) {
+      if ((error as NodeJS.ErrnoException).code !== "ENOENT") throw error;
+      this.instructions = [];
+    }
+    this.loaded = true;
+  }
+
+  isLoaded(): boolean {
+    return this.loaded;
+  }
+
+  list(): string[] {
+    return [...this.instructions];
+  }
+
+  async add(text: string): Promise<StandingInstructionResult> {
+    const instruction = normalizeInstruction(text);
+    if (!instruction) {
+      return { success: false, error: "A standing instruction cannot be empty." };
+    }
+
+    // Same scan every memory write goes through. A file the user is told is
+    // "always in context" is the most attractive injection target we have.
+    const blocked = scanContent(instruction);
+    if (blocked) return { success: false, error: blocked };
+
+    return this.mutate((current) => {
+      if (current.some((existing) => existing.toLowerCase() === instruction.toLowerCase())) {
+        return { error: "That standing instruction is already pinned." };
+      }
+      if (current.length >= this.maxEntries) {
+        return {
+          error: `Standing instructions are capped at ${this.maxEntries} entries`
+            + ` (currently ${current.length}). Remove one first with /memory-pin remove <n>.`,
+        };
+      }
+      const projected = [...current, instruction];
+      const projectedChars = projected.join("\n").length;
+      if (projectedChars > this.maxChars) {
+        return {
+          error: `Standing instructions are capped at ${this.maxChars} characters`
+            + ` and this entry would make ${projectedChars}. Shorten it, or remove an existing`
+            + ` instruction and keep long-form context in regular memory.`,
+        };
+      }
+      return { next: projected, message: `Pinned standing instruction ${projected.length}: ${instruction}` };
+    });
+  }
+
+  async remove(position: number): Promise<StandingInstructionResult> {
+    return this.mutate((current) => {
+      if (!Number.isInteger(position) || position < 1 || position > current.length) {
+        return {
+          error: current.length === 0
+            ? "There are no standing instructions to remove."
+            : `Position must be between 1 and ${current.length}.`,
+        };
+      }
+      const [removed] = current.slice(position - 1, position);
+      const next = current.filter((_, index) => index !== position - 1);
+      return { next, message: `Removed standing instruction: ${removed}` };
+    });
+  }
+
+  async clear(): Promise<StandingInstructionResult> {
+    return this.mutate((current) => (
+      current.length === 0
+        ? { error: "There are no standing instructions to clear." }
+        : { next: [], message: `Removed all ${current.length} standing instructions.` }
+    ));
+  }
+
+  /**
+   * Render the always-injected block, truncated to the budget.
+   *
+   * A hand-edited STANDING.md can exceed the cap, and silently dropping rules
+   * from a block advertised as "always active" would be the worst possible
+   * failure. Over budget, the omission is stated inside the block itself so
+   * both the model and /memory-preview-context can see it.
+   */
+  render(): StandingInstructionRender {
+    if (this.instructions.length === 0) {
+      return { block: "", injectedCount: 0, omittedCount: 0 };
+    }
+
+    const injected: string[] = [];
+    let used = 0;
+    for (const instruction of this.instructions) {
+      const cost = instruction.length + 1;
+      if (injected.length >= this.maxEntries || used + cost > this.maxChars) break;
+      injected.push(instruction);
+      used += cost;
+    }
+
+    const omittedCount = this.instructions.length - injected.length;
+    if (injected.length === 0) {
+      return { block: "", injectedCount: 0, omittedCount };
+    }
+
+    const lines = [
+      "<standing-instructions>",
+      "The user wrote the rules below and they are always active. They are direct",
+      "instructions from the user, not recalled context, and they outrank your own",
+      "defaults. Follow them without being asked and without looking them up.",
+      "",
+      ...injected.map((instruction, index) => `${index + 1}. ${instruction}`),
+    ];
+    if (omittedCount > 0) {
+      lines.push(
+        "",
+        `[!] ${omittedCount} further standing instruction${omittedCount === 1 ? "" : "s"} could not be shown:`
+        + ` ${path.basename(this.filePath)} exceeds the ${this.maxChars}-character injection budget.`
+        + " Trim it with /memory-pin so every rule stays active.",
+      );
+    }
+    lines.push("</standing-instructions>");
+
+    return { block: lines.join("\n"), injectedCount: injected.length, omittedCount };
+  }
+
+  formatForSystemPrompt(): string {
+    return this.render().block;
+  }
+
+  /**
+   * Read-modify-write under the same mutation lock the Markdown stores use, so
+   * a pin from a second session cannot clobber one from the first.
+   */
+  private async mutate(
+    change: (current: string[]) => { next?: string[]; message?: string; error?: string },
+  ): Promise<StandingInstructionResult> {
+    await fs.mkdir(path.dirname(this.filePath), { recursive: true });
+    try {
+      return await withMarkdownMutationLock(this.filePath, async () => {
+        await this.load();
+        const outcome = change(this.instructions);
+        if (outcome.error || !outcome.next) {
+          return { success: false, error: outcome.error ?? "Nothing to change.", instructions: this.list() };
+        }
+        await this.write(outcome.next);
+        this.instructions = outcome.next;
+        return { success: true, message: outcome.message, instructions: this.list() };
+      });
+    } catch (error) {
+      return { success: false, error: `Could not update standing instructions: ${String(error).slice(0, 200)}` };
+    }
+  }
+
+  /** Atomic write: temp file in the same directory, then rename. */
+  private async write(instructions: string[]): Promise<void> {
+    const content = instructions.length ? `${instructions.join("\n")}\n` : "";
+    const tmpDir = await fs.mkdtemp(path.join(path.dirname(this.filePath), ".tmp-standing-"));
+    const tmpPath = path.join(tmpDir, "write.tmp");
+    try {
+      await fs.writeFile(tmpPath, content, "utf-8");
+      await fs.rename(tmpPath, this.filePath);
+    } finally {
+      await fs.rm(tmpDir, { recursive: true, force: true });
+    }
+  }
+}
+
+/**
+ * One instruction per line. Blank lines, `#` comments and a leading `-`/`*`
+ * bullet are tolerated so a hand-edited STANDING.md stays a normal Markdown
+ * file rather than a format the user has to get exactly right.
+ */
+function parseInstructions(raw: string): string[] {
+  const seen = new Set<string>();
+  const instructions: string[] = [];
+  for (const line of raw.split("\n")) {
+    const instruction = normalizeInstruction(line);
+    if (!instruction || instruction.startsWith("#")) continue;
+    const key = instruction.toLowerCase();
+    if (seen.has(key)) continue;
+    seen.add(key);
+    instructions.push(instruction);
+  }
+  return instructions;
+}
+
+function normalizeInstruction(text: string): string {
+  return text.replace(/^\s*[-*]\s+/, "").replace(/\s+/g, " ").trim();
+}

package/dist/extensions/pi-hermes-memory/src/tools/memory-search-tool.ts

@@ -0,0 +1,95 @@
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { Type } from "typebox";
+import { StringEnum } from "@earendil-works/pi-ai";
+import { DatabaseManager } from '../store/db.js';
+import { searchMemories, getMemoryStats } from '../store/sqlite-memory-store.js';
+import type { MemoryCategory } from '../types.js';
+import { createSharedToolResultRenderer } from './shared-output-view.js';
+import { searchResultView } from './tool-result-views.js';
+
+interface SearchResult {
+  success: boolean;
+  count?: number;
+  message?: string;
+  output?: string;
+}
+
+function mutationTarget(entry: { target: "memory" | "user" | "failure"; project: string | null }): "memory" | "user" | "failure" | "project" {
+  // A project name scopes ordinary memory entries, but project-attributed
+  // failures still live in (and must be mutated through) the failure store.
+  return entry.target === "memory" && entry.project ? "project" : entry.target;
+}
+
+function scopeLabel(project: string | null): string {
+  return project ? `project:${encodeURIComponent(project)}` : "global";
+}
+
+export function registerMemorySearchTool(pi: ExtensionAPI, dbManager: DatabaseManager): void {
+  pi.registerTool({
+    name: 'memory_search',
+    label: 'Memory Search',
+    description: `Search extended memory store for relevant entries. Use this when you need context beyond what's in the system prompt — the extended store has unlimited capacity and is searchable.
+
+Use cases:
+- Find memories about a specific topic: "What do I know about auth setup?"
+- Search project-specific memories: "What conventions does project X follow?"
+- Find user preferences: "What are the user's testing preferences?"
+- Search for past failures: "memory_search('auth', category='failure')"
+
+Returns matching memory entries with their mutation target, scope, and dates. The displayed target is the value required by memory_replace and memory_remove.`,
+    promptSnippet: 'Search extended memory store (unlimited capacity)',
+    promptGuidelines: [
+      'Use memory_search when you need context beyond what is in the system prompt.',
+      'Use memory_search to find project-specific memories or user preferences.',
+      'Use memory_search with category filter to find specific types of memories (failure, correction, insight, etc.).',
+    ],
+    renderResult: createSharedToolResultRenderer(searchResultView),
+    parameters: Type.Object({
+      query: Type.String({ description: 'Search query. Use natural language or specific terms.' }),
+      project: Type.Optional(Type.String({ description: 'Filter by project name. Pass null for global memories only.' })),
+      target: Type.Optional(StringEnum(['memory', 'user', 'failure'] as const, { description: 'Filter by target type (memory, user, or failure).' })),
+      category: Type.Optional(StringEnum(['failure', 'correction', 'insight', 'preference', 'convention', 'tool-quirk'] as const, { description: 'Filter by memory category.' })),
+      limit: Type.Optional(Type.Number({ description: 'Maximum results to return (default: 10, max: 20).' })),
+    }),
+    execute: async (_id: string, args: { query: string; project?: string; target?: string; category?: string; limit?: number }) => {
+      const query = args.query;
+      const project = args.project;
+      const target = args.target;
+      const category = args.category as MemoryCategory | undefined;
+      const limit = Math.min(args.limit || 10, 20);
+
+      if (!query || query.trim().length === 0) {
+        const result: SearchResult = { success: false, message: 'query is required' };
+        return { content: [{ type: 'text' as const, text: result.message! }], details: result };
+      }
+
+      const stats = getMemoryStats(dbManager);
+      if (stats.total === 0) {
+        const result: SearchResult = { success: false, message: 'No memories in extended store yet. Use memory_add to store memories.' };
+        return { content: [{ type: 'text' as const, text: result.message! }], details: result };
+      }
+
+      const results = searchMemories(dbManager, query, { project, target, category, limit });
+
+      if (results.length === 0) {
+        const result: SearchResult = { success: true, count: 0, message: `No memories found matching "${query}". Try a different search term or broader query.` };
+        return { content: [{ type: 'text' as const, text: result.message! }], details: result };
+      }
+
+      let output = `Found ${results.length} memories matching "${query}":\n\n`;
+
+      for (const entry of results) {
+        const target = mutationTarget(entry);
+        const projectLabel = `scope=${scopeLabel(entry.project)}`;
+        const mutationTargetLabel = `[target=${target}]`;
+        const targetLabel = entry.target === 'user' ? '👤' : entry.target === 'failure' ? '⚠️' : '🧠';
+        const categoryLabel = entry.category ? ` [${entry.category}]` : '';
+        output += `${targetLabel} ${projectLabel} ${mutationTargetLabel}${categoryLabel} ${entry.content}\n`;
+        output += `   Created: ${entry.created} | Last used: ${entry.lastReferenced}\n\n`;
+      }
+
+      const finalResult: SearchResult = { success: true, count: results.length, output: output.trim() };
+      return { content: [{ type: 'text' as const, text: output.trim() }], details: finalResult };
+    },
+  });
+}