@pi-unipi/unipi 2.6.0 → 2.6.2

package/packages/compactor/src/display/tool-overrides.ts

@@ -1,136 +0,0 @@
-/**
- * Tool override renderers — mode-aware output for built-in tools
- */
-
-import type { OutputMode } from "../types.js";
-import { previewLines, countNonEmptyLines, shortenPath } from "./render-utils.js";
-
-export interface ToolOverrideConfig {
-  readOutputMode?: OutputMode;
-  searchOutputMode?: OutputMode;
-  bashOutputMode?: OutputMode;
-  previewLines?: number;
-  bashCollapsedLines?: number;
-  showTruncationHints?: boolean;
-}
-
-export function renderReadResult(
-  content: string,
-  filePath: string,
-  config: ToolOverrideConfig,
-): string {
-  switch (config.readOutputMode) {
-    case "hidden":
-      return `[Read: ${shortenPath(filePath)}]`;
-    case "summary":
-      return `[Read: ${shortenPath(filePath)} — ${countNonEmptyLines(content)} lines]`;
-    case "preview":
-      return previewLines(content, config.previewLines ?? 20);
-    default:
-      return content;
-  }
-}
-
-export function renderSearchResult(
-  results: string,
-  config: ToolOverrideConfig,
-): string {
-  switch (config.searchOutputMode) {
-    case "hidden":
-      return `[Search results hidden]`;
-    case "count":
-      return `[Search: ${countNonEmptyLines(results)} matches]`;
-    case "preview":
-      return previewLines(results, config.previewLines ?? 20);
-    default:
-      return results;
-  }
-}
-
-export function renderBashResult(
-  output: string,
-  command: string,
-  config: ToolOverrideConfig,
-): string {
-  switch (config.bashOutputMode) {
-    case "hidden":
-      return `[Bash: ${command.slice(0, 60)}]`;
-    case "summary":
-      return `[Bash: ${command.slice(0, 60)} — ${countNonEmptyLines(output)} lines]`;
-    case "preview":
-      return previewLines(output, config.bashCollapsedLines ?? 5);
-    default:
-      return output;
-  }
-}
-
-/**
- * Apply display overrides for built-in tool results.
- * Returns modified event result if override applies, undefined otherwise.
- *
- * Call this from the `tool_result` event handler to intercept and transform
- * tool output before it enters the LLM context.
- */
-export function applyToolDisplayOverride(
-  toolName: string,
-  event: Record<string, unknown>,
-  config: ToolOverrideConfig,
-): { content?: Array<{ type: string; text: string }> } | undefined {
-  const content = (event as any).content as Array<{ type: string; text: string }> | undefined;
-  if (!content || !Array.isArray(content) || content.length === 0) return undefined;
-
-  const textContent = content[0]?.text ?? "";
-  const previewLinesCount = config.previewLines ?? 20;
-  const collapsedLines = config.bashCollapsedLines ?? 5;
-
-  let overridden: string | undefined;
-
-  switch (toolName) {
-    case "read": {
-      const filePath = String((event as any).args?.path ?? "");
-      const mode = config.readOutputMode ?? "full";
-      if (mode === "hidden") {
-        overridden = `[Read: ${shortenPath(filePath)}]`;
-      } else if (mode === "summary") {
-        overridden = `[Read: ${shortenPath(filePath)} — ${countNonEmptyLines(textContent)} lines]`;
-      } else if (mode === "preview") {
-        overridden = previewLines(textContent, previewLinesCount);
-      }
-      break;
-    }
-    case "grep":
-    case "find":
-    case "ls": {
-      const mode = config.searchOutputMode ?? "full";
-      if (mode === "hidden") {
-        overridden = `[${toolName} results hidden]`;
-      } else if (mode === "count") {
-        overridden = `[${toolName}: ${countNonEmptyLines(textContent)} matches]`;
-      } else if (mode === "preview") {
-        overridden = previewLines(textContent, previewLinesCount);
-      }
-      break;
-    }
-    case "bash": {
-      const command = String((event as any).args?.command ?? "");
-      const mode = config.bashOutputMode ?? "full";
-      if (mode === "hidden") {
-        overridden = `[Bash: ${command.slice(0, 60)}]`;
-      } else if (mode === "summary") {
-        overridden = `[Bash: ${command.slice(0, 60)} — ${countNonEmptyLines(textContent)} lines]`;
-      } else if (mode === "preview") {
-        overridden = previewLines(textContent, collapsedLines);
-      }
-      break;
-    }
-    default:
-      return undefined;
-  }
-
-  if (overridden !== undefined) {
-    return {
-      content: [{ type: "text", text: overridden }],
-    };
-  }
-  return undefined;
-}

package/packages/compactor/src/tools/compact.ts

@@ -1,20 +0,0 @@
-/**
- * compact tool — trigger manual compaction with stats
- */
-
-import type { CompactionStats } from "../types.js";
-
-export interface CompactResult {
-  success: boolean;
-  stats?: CompactionStats;
-  message: string;
-}
-
-export function compactTool(): CompactResult {
-  // The actual compaction is handled by the session_before_compact hook.
-  // This tool just signals the intent and returns current stats.
-  return {
-    success: true,
-    message: "Compaction triggered. Stats will be available after next compact event.",
-  };
-}

package/packages/subagents/src/file-lock.ts

@@ -1,102 +0,0 @@
-/**
- * @pi-unipi/subagents — Per-file transparent locking
- *
- * Agents never see lock errors. Write tool queues internally.
- * Per-file granularity: locking src/auth.ts doesn't block src/login.ts.
- */
-
-import type { FileLockEntry } from "./types.js";
-
-export class FileLock {
-  /** Active locks by file path. */
-  private locks = new Map<string, FileLockEntry>();
-  /** Queue of waiting acquires per file path. */
-  private queues = new Map<string, Array<() => void>>();
-
-  /**
-   * Acquire a lock on a file. Blocks until available.
-   * Returns a release function.
-   *
-   * @param filePath - Absolute path to the file
-   * @param agentId - ID of the agent requesting the lock
-   * @returns Release function — call when done writing
-   */
-  async acquire(filePath: string, agentId: string): Promise<() => void> {
-    // Wait for existing lock
-    while (this.locks.has(filePath)) {
-      await new Promise<void>((resolve) => {
-        const queue = this.queues.get(filePath) ?? [];
-        queue.push(resolve);
-        this.queues.set(filePath, queue);
-      });
-    }
-
-    // Create lock entry
-    let releaseFn: () => void;
-    const promise = new Promise<void>((resolve) => {
-      releaseFn = () => {
-        this.locks.delete(filePath);
-        resolve();
-        // Wake next waiter
-        const queue = this.queues.get(filePath);
-        if (queue && queue.length > 0) {
-          const next = queue.shift()!;
-          next();
-        }
-      };
-    });
-
-    const entry: FileLockEntry = {
-      agentId,
-      filePath,
-      promise,
-      release: releaseFn!,
-    };
-
-    this.locks.set(filePath, entry);
-    return releaseFn!;
-  }
-
-  /**
-   * Check if a file is currently locked.
-   */
-  isLocked(filePath: string): boolean {
-    return this.locks.has(filePath);
-  }
-
-  /**
-   * Get the agent that holds a lock on a file.
-   */
-  getHolder(filePath: string): string | undefined {
-    return this.locks.get(filePath)?.agentId;
-  }
-
-  /**
-   * Get count of locked files.
-   */
-  get lockCount(): number {
-    return this.locks.size;
-  }
-
-  /**
-   * Release all locks held by an agent (on abort).
-   */
-  releaseAll(agentId: string): void {
-    for (const [filePath, entry] of this.locks) {
-      if (entry.agentId === agentId) {
-        entry.release();
-      }
-    }
-  }
-
-  /**
-   * Clear all locks (on shutdown).
-   */
-  clear(): void {
-    for (const entry of this.locks.values()) {
-      entry.release();
-    }
-    this.locks.clear();
-    this.queues.clear();
-  }
-}

package/packages/utility/src/cache/ttl-cache.ts

@@ -1,311 +0,0 @@
-/**
- * @pi-unipi/utility — TTL Cache
- *
- * General-purpose TTL cache with memory + SQLite backends.
- */
-
-import type { CacheEntry, CacheBackend, TTLCacheOptions } from "../types.js";
-
-// ─── Memory Backend ──────────────────────────────────────────────────────────
-
-class MemoryBackend<K, V> implements CacheBackend<K, V> {
-  private store = new Map<K, CacheEntry<V>>();
-  private maxEntries: number;
-
-  constructor(maxEntries: number = 1000) {
-    this.maxEntries = maxEntries;
-  }
-
-  async get(key: K): Promise<V | undefined> {
-    const entry = this.store.get(key);
-    if (!entry) return undefined;
-    if (Date.now() > entry.expiresAt) {
-      this.store.delete(key);
-      return undefined;
-    }
-    return entry.value;
-  }
-
-  async set(key: K, value: V, ttlMs: number): Promise<void> {
-    // Evict oldest if at capacity
-    if (this.store.size >= this.maxEntries && !this.store.has(key)) {
-      const firstKey = this.store.keys().next().value;
-      if (firstKey !== undefined) {
-        this.store.delete(firstKey);
-      }
-    }
-
-    const now = Date.now();
-    this.store.set(key, {
-      value,
-      expiresAt: now + ttlMs,
-      createdAt: now,
-    });
-  }
-
-  async has(key: K): Promise<boolean> {
-    const entry = this.store.get(key);
-    if (!entry) return false;
-    if (Date.now() > entry.expiresAt) {
-      this.store.delete(key);
-      return false;
-    }
-    return true;
-  }
-
-  async delete(key: K): Promise<boolean> {
-    return this.store.delete(key);
-  }
-
-  async cleanupExpired(): Promise<number> {
-    const now = Date.now();
-    let count = 0;
-    for (const [key, entry] of this.store) {
-      if (now > entry.expiresAt) {
-        this.store.delete(key);
-        count++;
-      }
-    }
-    return count;
-  }
-
-  async clear(): Promise<void> {
-    this.store.clear();
-  }
-}
-
-// ─── SQLite Backend ──────────────────────────────────────────────────────────
-
-// Minimal sqlite3 type declarations for lazy loading
-interface Sqlite3Db {
-  run(sql: string, callback?: (err: Error | null) => void): Sqlite3Db;
-  run(sql: string, params: unknown[], callback?: (err: Error | null) => void): Sqlite3Db;
-  get(sql: string, params: unknown[], callback: (err: Error | null, row: unknown) => void): Sqlite3Db;
-  close(callback?: (err: Error | null) => void): void;
-}
-
-interface Sqlite3 {
-  Database: new (path: string) => Sqlite3Db;
-}
-
-// Lazy-load sqlite to avoid hard dependency
-let sqlite3: Sqlite3 | null = null;
-let sqliteLoadAttempted = false;
-
-async function loadSqlite(): Promise<Sqlite3 | null> {
-  if (sqliteLoadAttempted) return sqlite3;
-  sqliteLoadAttempted = true;
-  try {
-    // Use dynamic import with type assertion to bypass module resolution
-    const mod = await eval("import('sqlite3')") as { default?: Sqlite3; Database?: unknown } | Sqlite3;
-    if (mod && typeof mod === "object") {
-      // Handle both ESM default export and CJS-style export
-      sqlite3 = (mod as { default?: Sqlite3 }).default ?? (mod as Sqlite3);
-    }
-  } catch {
-    sqlite3 = null;
-  }
-  return sqlite3;
-}
-
-class SQLiteBackend<K, V> implements CacheBackend<K, V> {
-  private db: Sqlite3Db | null = null;
-  private dbPath: string;
-  private ready: Promise<void>;
-
-  constructor(dbPath: string) {
-    this.dbPath = dbPath;
-    this.ready = this.init();
-  }
-
-  private async init(): Promise<void> {
-    const sqlite = await loadSqlite();
-    if (!sqlite) {
-      throw new Error("sqlite3 not available for persistent cache");
-    }
-    this.db = new sqlite.Database(this.dbPath);
-
-    await new Promise<void>((resolve, reject) => {
-      this.db!.run(
-        `CREATE TABLE IF NOT EXISTS cache (
-          key TEXT PRIMARY KEY,
-          value TEXT NOT NULL,
-          expires_at INTEGER NOT NULL,
-          created_at INTEGER NOT NULL
-        )`,
-        (err: Error | null) => (err ? reject(err) : resolve()),
-      );
-    });
-
-    // Create index for fast expiration queries
-    await new Promise<void>((resolve, reject) => {
-      this.db!.run(
-        `CREATE INDEX IF NOT EXISTS idx_expires ON cache(expires_at)`,
-        (err: Error | null) => (err ? reject(err) : resolve()),
-      );
-    });
-  }
-
-  private async ensureReady(): Promise<void> {
-    await this.ready;
-  }
-
-  async get(key: K): Promise<V | undefined> {
-    await this.ensureReady();
-    if (!this.db) return undefined;
-
-    const row = await new Promise<{ value: string; expires_at: number } | undefined>(
-      (resolve, reject) => {
-        this.db!.get(
-          "SELECT value, expires_at FROM cache WHERE key = ?",
-          [String(key)],
-          (err: Error | null, row: unknown) => {
-            if (err) reject(err);
-            else resolve(row as { value: string; expires_at: number } | undefined);
-          },
-        );
-      },
-    );
-
-    if (!row) return undefined;
-    if (Date.now() > row.expires_at) {
-      await this.delete(key);
-      return undefined;
-    }
-
-    try {
-      return JSON.parse(row.value) as V;
-    } catch {
-      return undefined;
-    }
-  }
-
-  async set(key: K, value: V, ttlMs: number): Promise<void> {
-    await this.ensureReady();
-    if (!this.db) return;
-
-    const now = Date.now();
-    const expiresAt = now + ttlMs;
-    const serialized = JSON.stringify(value);
-
-    await new Promise<void>((resolve, reject) => {
-      this.db!.run(
-        `INSERT INTO cache (key, value, expires_at, created_at)
-         VALUES (?, ?, ?, ?)
-         ON CONFLICT(key) DO UPDATE SET
-           value = excluded.value,
-           expires_at = excluded.expires_at,
-           created_at = excluded.created_at`,
-        [String(key), serialized, expiresAt, now],
-        (err: Error | null) => (err ? reject(err) : resolve()),
-      );
-    });
-  }
-
-  async has(key: K): Promise<boolean> {
-    const value = await this.get(key);
-    return value !== undefined;
-  }
-
-  async delete(key: K): Promise<boolean> {
-    await this.ensureReady();
-    if (!this.db) return false;
-
-    return new Promise<boolean>((resolve, reject) => {
-      this.db!.run(
-        "DELETE FROM cache WHERE key = ?",
-        [String(key)],
-        function (this: { changes: number }, err: Error | null) {
-          if (err) reject(err);
-          else resolve(this.changes > 0);
-        },
-      );
-    });
-  }
-
-  async cleanupExpired(): Promise<number> {
-    await this.ensureReady();
-    if (!this.db) return 0;
-
-    return new Promise<number>((resolve, reject) => {
-      this.db!.run(
-        "DELETE FROM cache WHERE expires_at <= ?",
-        [Date.now()],
-        function (this: { changes: number }, err: Error | null) {
-          if (err) reject(err);
-          else resolve(this.changes);
-        },
-      );
-    });
-  }
-
-  async clear(): Promise<void> {
-    await this.ensureReady();
-    if (!this.db) return;
-
-    await new Promise<void>((resolve, reject) => {
-      this.db!.run("DELETE FROM cache", (err: Error | null) => (err ? reject(err) : resolve()));
-    });
-  }
-}
-
-// ─── TTL Cache ───────────────────────────────────────────────────────────────
-
-/** Default options */
-const DEFAULTS: Required<TTLCacheOptions> = {
-  persistent: false,
-  dbPath: "",
-  defaultTtlMs: 3600000, // 1 hour
-  maxMemoryEntries: 1000,
-};
-
-/**
- * General-purpose TTL cache with optional SQLite persistence.
- */
-export class TTLCache<K = string, V = unknown> {
-  private backend: CacheBackend<K, V>;
-  private opts: Required<TTLCacheOptions>;
-
-  constructor(options: TTLCacheOptions = {}) {
-    this.opts = { ...DEFAULTS, ...options };
-
-    if (this.opts.persistent) {
-      const dbPath =
-        this.opts.dbPath ||
-        new URL("~/.unipi/cache/ttl-cache.db", import.meta.url).pathname;
-      this.backend = new SQLiteBackend<K, V>(dbPath);
-    } else {
-      this.backend = new MemoryBackend<K, V>(this.opts.maxMemoryEntries);
-    }
-  }
-
-  /** Get a value by key */
-  async get(key: K): Promise<V | undefined> {
-    return this.backend.get(key);
-  }
-
-  /** Set a value with TTL */
-  async set(key: K, value: V, ttlMs?: number): Promise<void> {
-    return this.backend.set(key, value, ttlMs ?? this.opts.defaultTtlMs);
-  }
-
-  /** Check if key exists and is not expired */
-  async has(key: K): Promise<boolean> {
-    return this.backend.has(key);
-  }
-
-  /** Delete a key */
-  async delete(key: K): Promise<boolean> {
-    return this.backend.delete(key);
-  }
-
-  /** Clean up all expired entries */
-  async cleanupExpired(): Promise<number> {
-    return this.backend.cleanupExpired();
-  }
-
-  /** Clear all entries */
-  async clear(): Promise<void> {
-    return this.backend.clear();
-  }
-}