@chendpoc/pi-memory 0.1.13 → 0.2.0

package/src/consolidation/index.ts

@@ -1,90 +0,0 @@
-export type {
-  ConsolidationStatus,
-  ConsolidationStatusReport,
-  JobReport,
-  PendingSession,
-  Stage1Output,
-} from "./types.js";
-
-export {
-  getMemoryIndexStats,
-  memoryIndexSnippet,
-  readMemoryIndexCap,
-  type MemoryIndexCapOptions,
-  type MemoryIndexStats,
-} from "./memoryIndex.js";
-
-export {
-  findGitRoot,
-  lineMatchesScope,
-  parseScopeComment,
-  projectHash,
-  projectScope,
-  scopeForCwd,
-  type MemoryScope,
-} from "./scope.js";
-
-export {
-  appendConsolidationLog,
-  readRecentConsolidationLogs,
-  type ConsolidationLogEntry,
-} from "./log.js";
-
-export { withFileLock } from "./lock.js";
-
-export { enqueueSession, getConsolidationStatus } from "./enqueue.js";
-export type {
-  ConsolidationStatusQueryOptions,
-  EnqueueOptions,
-  EnqueueSessionInput,
-} from "./enqueue.js";
-
-export { openConsolidationStore } from "./stage1/store.js";
-export type { SqliteDatabase, ConsolidationStore } from "./stage1/store.js";
-
-export {
-  computeDeltaTurns,
-} from "./stage1/deltaExtract.js";
-
-export {
-  drainQueue,
-  type DrainQueueOptions,
-  type DrainQueueReport,
-} from "./stage1/drainQueue.js";
-
-export { extractSessionToStage1 } from "./stage1/extractSession.js";
-
-export {
-  runPhase2,
-  type Phase2Options,
-  type Phase2Report,
-} from "./phase2/runPhase2.js";
-
-export {
-  defaultConsolidationDbPath,
-  runConsolidate,
-  type ConsolidateOptions,
-  type ConsolidateReport,
-} from "./scheduler/runConsolidate.js";
-
-export {
-  buildLaunchdPlist,
-  launchdPlistPath,
-} from "./scheduler/launchd.js";
-
-export {
-  buildSystemdService,
-  buildSystemdTimer,
-  systemdServicePath,
-  systemdTimerPath,
-} from "./scheduler/systemd.js";
-
-export { setupSchedule } from "./scheduler/setupSchedule.js";
-
-export type {
-  ScheduleAction,
-  ScheduledFile,
-  ScheduleOptions,
-  SchedulePlatform,
-  SetupScheduleResult,
-} from "./scheduler/types.js";

package/src/consolidation/lock.ts

@@ -1,41 +0,0 @@
-import fs from "node:fs/promises";
-import path from "node:path";
-
-const LOCK_RETRIES = 50;
-const LOCK_DELAY_MS = 100;
-
-async function sleep(ms: number): Promise<void> {
-  await new Promise((resolve) => setTimeout(resolve, ms));
-}
-
-export async function withFileLock<T>(
-  lockPath: string,
-  fn: () => Promise<T>,
-  opts: { retries?: number; delayMs?: number } = {},
-): Promise<T> {
-  const retries = opts.retries ?? LOCK_RETRIES;
-  const delayMs = opts.delayMs ?? LOCK_DELAY_MS;
-  let handle: fs.FileHandle | null = null;
-
-  await fs.mkdir(path.dirname(lockPath), { recursive: true, mode: 0o700 });
-
-  for (let i = 0; i < retries; i++) {
-    try {
-      handle = await fs.open(lockPath, "wx");
-      break;
-    } catch {
-      await sleep(delayMs);
-    }
-  }
-
-  if (!handle) {
-    throw new Error(`could not acquire lock: ${lockPath}`);
-  }
-
-  try {
-    return await fn();
-  } finally {
-    await handle.close().catch(() => {});
-    await fs.unlink(lockPath).catch(() => {});
-  }
-}

package/src/consolidation/log.ts

@@ -1,43 +0,0 @@
-import fs from "node:fs/promises";
-import path from "node:path";
-
-export interface ConsolidationLogEntry {
-  ts?: string;
-  phase: string;
-  [key: string]: unknown;
-}
-
-export async function appendConsolidationLog(
-  logPath: string,
-  entry: ConsolidationLogEntry,
-): Promise<void> {
-  await fs.mkdir(path.dirname(logPath), { recursive: true, mode: 0o700 });
-  const line = JSON.stringify({
-    ts: entry.ts ?? new Date().toISOString(),
-    ...entry,
-  });
-  await fs.appendFile(logPath, `${line}\n`, { encoding: "utf8", mode: 0o600 });
-}
-
-export async function readRecentConsolidationLogs(
-  logPath: string,
-  limit = 5,
-): Promise<ConsolidationLogEntry[]> {
-  let text: string;
-  try {
-    text = await fs.readFile(logPath, "utf8");
-  } catch {
-    return [];
-  }
-  return text
-    .split("\n")
-    .filter((line) => line.trim())
-    .slice(-limit)
-    .map((line) => {
-      try {
-        return JSON.parse(line) as ConsolidationLogEntry;
-      } catch {
-        return { phase: "invalid_log_line", raw: line };
-      }
-    });
-}

package/src/consolidation/memoryIndex.ts

@@ -1,127 +0,0 @@
-import fs from "node:fs";
-import fsPromises from "node:fs/promises";
-
-import {
-  lineMatchesScope,
-  type MemoryScope,
-} from "./scope.js";
-
-export interface MemoryIndexCapOptions {
-  maxLines?: number;
-  maxBytes?: number;
-  scopes?: readonly MemoryScope[];
-}
-
-export interface MemoryIndexStats {
-  path: string;
-  exists: boolean;
-  lines: number;
-  bytes: number;
-  cappedLines: number;
-  cappedBytes: number;
-}
-
-const DEFAULT_MAX_LINES = 200;
-const DEFAULT_MAX_BYTES = 25_600;
-
-function capLines(
-  text: string,
-  opts: Required<Pick<MemoryIndexCapOptions, "maxLines" | "maxBytes">> & {
-    scopes?: readonly MemoryScope[];
-  },
-): string {
-  const out: string[] = [];
-  let bytes = 0;
-  for (const line of text.split("\n")) {
-    if (out.length >= opts.maxLines) break;
-    if (!lineMatchesScope(line, opts.scopes)) continue;
-    const nextBytes = Buffer.byteLength(line + "\n", "utf8");
-    if (bytes + nextBytes > opts.maxBytes) break;
-    out.push(line);
-    bytes += nextBytes;
-  }
-  return out.join("\n").trim();
-}
-
-function normalizedOptions(opts: MemoryIndexCapOptions = {}) {
-  return {
-    maxLines: opts.maxLines ?? DEFAULT_MAX_LINES,
-    maxBytes: opts.maxBytes ?? DEFAULT_MAX_BYTES,
-    scopes: opts.scopes,
-  };
-}
-
-export function readMemoryIndexCap(
-  paths: string[],
-  opts: MemoryIndexCapOptions = {},
-): string {
-  const normalized = normalizedOptions(opts);
-  for (const p of paths) {
-    let text: string;
-    try {
-      text = fs.readFileSync(p, "utf8");
-    } catch {
-      continue;
-    }
-    const capped = capLines(text, normalized);
-    if (capped) return capped;
-  }
-  return "";
-}
-
-export async function memoryIndexSnippet(
-  paths: string[],
-  query: string,
-  opts: MemoryIndexCapOptions = {},
-): Promise<string> {
-  const q = query.trim().toLowerCase();
-  if (!q) return "";
-  const normalized = normalizedOptions(opts);
-
-  for (const p of paths) {
-    let text: string;
-    try {
-      text = await fsPromises.readFile(p, "utf8");
-    } catch {
-      continue;
-    }
-    const matches: string[] = [];
-    let bytes = 0;
-    for (const line of text.split("\n")) {
-      if (!lineMatchesScope(line, normalized.scopes)) continue;
-      if (!line.toLowerCase().includes(q)) continue;
-      const nextBytes = Buffer.byteLength(line + "\n", "utf8");
-      if (bytes + nextBytes > normalized.maxBytes) break;
-      matches.push(line);
-      bytes += nextBytes;
-      if (matches.length >= normalized.maxLines) break;
-    }
-    if (matches.length > 0) return matches.join("\n");
-  }
-  return "";
-}
-
-export function getMemoryIndexStats(
-  paths: string[],
-  opts: MemoryIndexCapOptions = {},
-): MemoryIndexStats[] {
-  const normalized = normalizedOptions(opts);
-  return paths.map((p) => {
-    let text = "";
-    let exists = true;
-    try {
-      text = fs.readFileSync(p, "utf8");
-    } catch {
-      exists = false;
-    }
-    const capped = exists ? capLines(text, normalized) : "";
-    return {
-      path: p,
-      exists,
-      lines: exists ? text.split("\n").length : 0,
-      bytes: exists ? Buffer.byteLength(text, "utf8") : 0,
-      cappedLines: capped ? capped.split("\n").length : 0,
-      cappedBytes: Buffer.byteLength(capped, "utf8"),
-    };
-  });
-}

package/src/consolidation/phase2/runPhase2.ts

@@ -1,255 +0,0 @@
-import fs from "node:fs/promises";
-import path from "node:path";
-
-import type { ConsolidationStore } from "../stage1/store.js";
-import type { Stage1Output } from "../types.js";
-
-export interface Phase2Options {
-  memoryMdPath: string;
-  bundleRoot: string;
-  topN: number;
-  dryRun?: boolean;
-  maxLines?: number;
-  maxBytes?: number;
-  maxUnusedDays?: number;
-}
-
-export interface Phase2Report {
-  stage1Selected: number;
-  appended: number;
-  skippedDedup: number;
-  backupsCreated: number;
-  topicsUpdated: number;
-  migratedProjectLines: number;
-  prunedLines: number;
-  dryRun: boolean;
-  targets: string[];
-}
-
-async function readFileOptional(filePath: string): Promise<string> {
-  try {
-    return await fs.readFile(filePath, "utf8");
-  } catch {
-    return "";
-  }
-}
-
-function stripScopeComment(line: string): string {
-  return line.replace(/<!--\s*scope:[^>]+-->/g, "").trim();
-}
-
-function normalizedLine(line: string): string {
-  return stripScopeComment(line).replace(/\s+/g, " ").toLowerCase();
-}
-
-function targetForRow(row: Stage1Output, opts: Phase2Options): string {
-  if (row.scope.startsWith("project:")) {
-    const hash = row.scope.slice("project:".length);
-    return path.join(opts.bundleRoot, "projects", hash, "MEMORY.md");
-  }
-  return opts.memoryMdPath;
-}
-
-function targetForScope(scope: string, opts: Phase2Options): string {
-  if (scope.startsWith("project:")) {
-    const hash = scope.slice("project:".length);
-    return path.join(opts.bundleRoot, "projects", hash, "MEMORY.md");
-  }
-  return opts.memoryMdPath;
-}
-
-function rowsToMemoryLines(row: Stage1Output): string[] {
-  const body = row.raw_memory.trim() || row.rollout_summary.trim();
-  if (!body) return [];
-  return body
-    .split("\n")
-    .map((line) => line.trim())
-    .filter(Boolean)
-    .map((line) => {
-      const bullet = line.startsWith("- ") ? line : `- ${line}`;
-      return `${bullet} <!-- scope:${row.scope} -->`;
-    });
-}
-
-async function backupMemoryFile(filePath: string): Promise<boolean> {
-  const existing = await readFileOptional(filePath);
-  if (!existing) return false;
-  const stamp = new Date().toISOString().replace(/[:.]/g, "-");
-  await fs.copyFile(filePath, `${filePath}.${stamp}.bak`);
-  return true;
-}
-
-async function appendDedup(
-  filePath: string,
-  lines: string[],
-  dryRun: boolean,
-): Promise<{ appended: number; skipped: number; backup: boolean }> {
-  if (lines.length === 0) return { appended: 0, skipped: 0, backup: false };
-  const existing = await readFileOptional(filePath);
-  const seen = new Set(
-    existing
-      .split("\n")
-      .map(normalizedLine)
-      .filter(Boolean),
-  );
-  const nextLines: string[] = [];
-  let skipped = 0;
-  for (const line of lines) {
-    const key = normalizedLine(line);
-    if (seen.has(key)) {
-      skipped++;
-      continue;
-    }
-    seen.add(key);
-    nextLines.push(line);
-  }
-  if (dryRun || nextLines.length === 0) {
-    return { appended: nextLines.length, skipped, backup: false };
-  }
-  await fs.mkdir(path.dirname(filePath), { recursive: true, mode: 0o700 });
-  const backup = await backupMemoryFile(filePath);
-  const prefix = existing.trim() ? "\n" : "# Memory\n\n";
-  await fs.appendFile(filePath, `${prefix}${nextLines.join("\n")}\n`, {
-    encoding: "utf8",
-    mode: 0o600,
-  });
-  return { appended: nextLines.length, skipped, backup };
-}
-
-async function migrateProjectScopedLines(
-  opts: Phase2Options,
-): Promise<{ migrated: number; targets: string[] }> {
-  const globalText = await readFileOptional(opts.memoryMdPath);
-  if (!globalText.trim()) return { migrated: 0, targets: [] };
-
-  const keep: string[] = [];
-  const byTarget = new Map<string, string[]>();
-  for (const line of globalText.split("\n")) {
-    const scope = line.match(/<!--\s*scope:(project:[a-f0-9]{12})\s*-->/i)?.[1];
-    if (!scope) {
-      keep.push(line);
-      continue;
-    }
-    const target = targetForScope(scope, opts);
-    byTarget.set(target, [...(byTarget.get(target) ?? []), line]);
-  }
-  const migrated = Array.from(byTarget.values()).reduce((sum, lines) => sum + lines.length, 0);
-  if (opts.dryRun || migrated === 0) {
-    return { migrated, targets: Array.from(byTarget.keys()) };
-  }
-
-  await backupMemoryFile(opts.memoryMdPath);
-  await fs.writeFile(opts.memoryMdPath, `${keep.join("\n").trim()}\n`, "utf8");
-  for (const [target, lines] of byTarget) {
-    await appendDedup(target, lines, false);
-  }
-  return { migrated, targets: Array.from(byTarget.keys()) };
-}
-
-async function pruneLinesFromTargets(
-  rows: Stage1Output[],
-  opts: Phase2Options,
-): Promise<number> {
-  if (rows.length === 0) return 0;
-  const staleKeys = new Set<string>();
-  for (const row of rows) {
-    for (const line of rowsToMemoryLines(row)) staleKeys.add(normalizedLine(line));
-  }
-  if (staleKeys.size === 0) return 0;
-
-  const targets = new Set<string>([
-    opts.memoryMdPath,
-    ...rows.map((row) => targetForRow(row, opts)),
-  ]);
-  let pruned = 0;
-  for (const target of targets) {
-    const existing = await readFileOptional(target);
-    if (!existing.trim()) continue;
-    const kept: string[] = [];
-    let targetPruned = 0;
-    for (const line of existing.split("\n")) {
-      if (staleKeys.has(normalizedLine(line))) {
-        pruned++;
-        targetPruned++;
-        continue;
-      }
-      kept.push(line);
-    }
-    if (!opts.dryRun && targetPruned > 0) {
-      await backupMemoryFile(target);
-      await fs.writeFile(target, `${kept.join("\n").trim()}\n`, "utf8");
-    }
-  }
-  return pruned;
-}
-
-async function syncWorkspace(
-  rows: Stage1Output[],
-  bundleRoot: string,
-  dryRun: boolean,
-): Promise<void> {
-  if (dryRun) return;
-  const workspace = path.join(bundleRoot, "workspace");
-  const summaries = path.join(workspace, "rollout_summaries");
-  await fs.mkdir(summaries, { recursive: true, mode: 0o700 });
-  const raw = rows
-    .map((row) => `## ${row.session_id}\n\n${row.raw_memory || row.rollout_summary}`)
-    .join("\n\n");
-  await fs.writeFile(path.join(workspace, "raw_memories.md"), `${raw}\n`, "utf8");
-  for (const row of rows) {
-    await fs.writeFile(
-      path.join(summaries, `${row.session_id}.md`),
-      `${row.rollout_summary || row.raw_memory}\n`,
-      "utf8",
-    );
-  }
-}
-
-export async function runPhase2(
-  store: ConsolidationStore,
-  opts: Phase2Options,
-): Promise<Phase2Report> {
-  const dryRun = opts.dryRun ?? false;
-  const rows = store.listUnselectedStage1(opts.topN);
-  const migration = await migrateProjectScopedLines(opts);
-  const grouped = new Map<string, string[]>();
-
-  for (const row of rows) {
-    const target = targetForRow(row, opts);
-    const lines = rowsToMemoryLines(row);
-    grouped.set(target, [...(grouped.get(target) ?? []), ...lines]);
-  }
-
-  const report: Phase2Report = {
-    stage1Selected: rows.length,
-    appended: 0,
-    skippedDedup: 0,
-    backupsCreated: 0,
-    topicsUpdated: 0,
-    migratedProjectLines: migration.migrated,
-    prunedLines: 0,
-    dryRun,
-    targets: Array.from(new Set([...grouped.keys(), ...migration.targets])),
-  };
-
-  for (const [target, lines] of grouped) {
-    const result = await appendDedup(target, lines, dryRun);
-    report.appended += result.appended;
-    report.skippedDedup += result.skipped;
-    if (result.backup) report.backupsCreated++;
-  }
-
-  await syncWorkspace(rows, opts.bundleRoot, dryRun);
-  if (opts.maxUnusedDays && opts.maxUnusedDays > 0) {
-    const cutoff = new Date(
-      Date.now() - opts.maxUnusedDays * 24 * 60 * 60 * 1000,
-    ).toISOString();
-    report.prunedLines = await pruneLinesFromTargets(
-      store.listStage1OlderThan(cutoff),
-      opts,
-    );
-  }
-  if (!dryRun) store.markStage1Selected(rows.map((row) => row.session_id));
-
-  return report;
-}

package/src/consolidation/scheduler/launchd.ts

@@ -1,62 +0,0 @@
-import os from "node:os";
-import path from "node:path";
-
-import type { ScheduleOptions } from "./types.js";
-
-export const LAUNCHD_LABEL = "dev.pi.memory-consolidate";
-const PLIST_FILE = `${LAUNCHD_LABEL}.plist`;
-
-function commandArgs(opts: ScheduleOptions): string[] {
-  if (opts.commandPath) {
-    return [opts.commandPath, "consolidate"];
-  }
-  if (opts.npxPath) {
-    return [opts.npxPath, "pi-memory", "consolidate"];
-  }
-  return ["pi-memory", "consolidate"];
-}
-
-function escapeXml(value: string): string {
-  return value
-    .replaceAll("&", "&")
-    .replaceAll("<", "&lt;")
-    .replaceAll(">", "&gt;");
-}
-
-export function launchdPlistPath(): string {
-  return path.join(os.homedir(), "Library", "LaunchAgents", PLIST_FILE);
-}
-
-export function buildLaunchdPlist(opts: ScheduleOptions): string {
-  const args = commandArgs(opts);
-
-  const argumentsXml = args
-    .map((arg) => `    <string>${escapeXml(arg)}</string>`)
-    .join("\n");
-
-  return [
-    `<?xml version="1.0" encoding="UTF-8"?>`,
-    `<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">`,
-    `<plist version="1.0">`,
-    `<dict>`,
-    `  <key>Label</key>`,
-    `  <string>${LAUNCHD_LABEL}</string>`,
-    `  <key>ProgramArguments</key>`,
-    `  <array>`,
-    `${argumentsXml}`,
-    `  </array>`,
-    `  <key>StandardOutPath</key>`,
-    `  <string>${escapeXml(opts.logPath)}</string>`,
-    `  <key>StandardErrorPath</key>`,
-    `  <string>${escapeXml(opts.logPath)}</string>`,
-    `  <key>StartCalendarInterval</key>`,
-    `  <dict>`,
-    `    <key>Hour</key>`,
-    `    <integer>${opts.hour}</integer>`,
-    `    <key>Minute</key>`,
-    `    <integer>${opts.minute}</integer>`,
-    `  </dict>`,
-    `</dict>`,
-    `</plist>`,
-  ].join("\n");
-}