@selesai/code 0.13.11 → 0.13.13

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

@@ -1,241 +0,0 @@
-/**
- * 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

@@ -1,247 +0,0 @@
-/**
- * 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

@@ -1,95 +0,0 @@
-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 };
-    },
-  });
-}