@chendpoc/pi-memory 0.1.13 → 0.2.0

package/src/consolidation/scheduler/runConsolidate.ts

@@ -1,115 +0,0 @@
-import path from "node:path";
-
-import type { MemoryConfig } from "../../config.js";
-import { trainBundle } from "../../trainer/index.js";
-import { withFileLock } from "../lock.js";
-import { appendConsolidationLog } from "../log.js";
-import { runPhase2, type Phase2Report } from "../phase2/runPhase2.js";
-import { drainQueue, type DrainQueueReport } from "../stage1/drainQueue.js";
-import { openConsolidationStore } from "../stage1/store.js";
-
-export interface ConsolidateOptions {
-  config: MemoryConfig;
-  dbPath?: string;
-  dryRun?: boolean;
-  phase1Only?: boolean;
-  phase2Only?: boolean;
-}
-
-export interface ConsolidateReport {
-  dryRun: boolean;
-  dbPath: string;
-  drain?: DrainQueueReport;
-  train?: {
-    sessionsProcessed: number;
-    entityCount: number;
-    relationCount: number;
-    eventCount: number;
-    dryRun: boolean;
-  };
-  phase2?: Phase2Report;
-}
-
-export function defaultConsolidationDbPath(cfg: MemoryConfig): string {
-  return path.join(cfg.bundleRoot, "memories.sqlite");
-}
-
-export async function runConsolidate(
-  opts: ConsolidateOptions,
-): Promise<ConsolidateReport> {
-  const cfg = opts.config;
-  const dbPath = opts.dbPath ?? defaultConsolidationDbPath(cfg);
-  const dryRun = opts.dryRun ?? false;
-  const lockPath = path.join(cfg.bundleRoot, ".consolidation.lock");
-  const logPath = cfg.consolidation.schedule.log_path;
-
-  return withFileLock(lockPath, async () => {
-    const store = openConsolidationStore(dbPath);
-    if (!store) {
-      throw new Error("better-sqlite3 unavailable; cannot open consolidation store");
-    }
-
-    try {
-      const report: ConsolidateReport = { dryRun, dbPath };
-
-      if (!opts.phase2Only) {
-        report.drain = await drainQueue(store, { dryRun });
-        await appendConsolidationLog(logPath, {
-          phase: "phase1",
-          sessions_processed: report.drain.sessionsProcessed,
-          sessions_skipped: report.drain.sessionsSkipped,
-          sessions_failed: report.drain.sessionsFailed,
-          stage1_new_rows: report.drain.stage1NewRows,
-          dry_run: dryRun,
-        });
-
-        const trainResult = await trainBundle({
-          sessionsDir: cfg.sessionsDir,
-          bundleRoot: cfg.bundleRoot,
-          dryRun,
-          full: false,
-        });
-        report.train = {
-          sessionsProcessed: trainResult.sessionsProcessed,
-          entityCount: trainResult.entityCount,
-          relationCount: trainResult.relationCount,
-          eventCount: trainResult.eventCount,
-          dryRun: trainResult.dryRun,
-        };
-        await appendConsolidationLog(logPath, {
-          phase: "graph_train",
-          sessions_processed: trainResult.sessionsProcessed,
-          entities: trainResult.entityCount,
-          relations: trainResult.relationCount,
-          events: trainResult.eventCount,
-          dry_run: dryRun,
-        });
-      }
-
-      if (!opts.phase1Only) {
-        const memoryMdPath = cfg.memoryMdPaths[0] ?? path.join(cfg.bundleRoot, "MEMORY.md");
-        report.phase2 = await runPhase2(store, {
-          memoryMdPath,
-          bundleRoot: cfg.bundleRoot,
-          topN: cfg.consolidation.phase2_top_n,
-          dryRun,
-          maxLines: cfg.consolidation.memory_index_max_lines,
-          maxBytes: cfg.consolidation.memory_index_max_bytes,
-          maxUnusedDays: cfg.consolidation.max_unused_days,
-        });
-        await appendConsolidationLog(logPath, {
-          phase: "phase2",
-          stage1_selected: report.phase2.stage1Selected,
-          appended: report.phase2.appended,
-          skipped_dedup: report.phase2.skippedDedup,
-          backups_created: report.phase2.backupsCreated,
-          dry_run: dryRun,
-        });
-      }
-
-      return report;
-    } finally {
-      store.close();
-    }
-  });
-}

package/src/consolidation/scheduler/setupSchedule.ts

@@ -1,106 +0,0 @@
-import fs from "node:fs/promises";
-import path from "node:path";
-
-import { buildLaunchdPlist, launchdPlistPath } from "./launchd.js";
-import {
-  buildSystemdService,
-  buildSystemdTimer,
-  systemdServicePath,
-  systemdTimerPath,
-} from "./systemd.js";
-import {
-  type SetupScheduleResult,
-  type ScheduledFile,
-  type ScheduleAction,
-  type ScheduleOptions,
-  type SchedulePlatform,
-} from "./types.js";
-
-async function exists(filePath: string): Promise<boolean> {
-  try {
-    await fs.access(filePath);
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-async function ensureDir(filePath: string): Promise<void> {
-  await fs.mkdir(path.dirname(filePath), { recursive: true });
-}
-
-async function writeIfNeeded(
-  filePath: string,
-  content: string,
-  dryRun: boolean,
-): Promise<void> {
-  if (dryRun) return;
-  await ensureDir(filePath);
-  await fs.writeFile(filePath, content, "utf8");
-}
-
-async function removeFileIfExists(filePath: string, dryRun: boolean): Promise<void> {
-  if (dryRun) return;
-  try {
-    await fs.rm(filePath, { force: true });
-  } catch {
-    // Ignore cleanup failures for idempotency.
-  }
-}
-
-function setupPlan(
-  platform: SchedulePlatform,
-  opts: ScheduleOptions,
-): Array<{ path: string; content: string }> {
-  if (platform === "darwin") {
-    return [{ path: launchdPlistPath(), content: buildLaunchdPlist(opts) }];
-  }
-  return [
-    { path: systemdServicePath(), content: buildSystemdService(opts) },
-    { path: systemdTimerPath(), content: buildSystemdTimer(opts) },
-  ];
-}
-
-function resolveAction(opts: ScheduleOptions): ScheduleAction {
-  if (opts.status) return "status";
-  if (opts.remove) return "remove";
-  return "write";
-}
-
-export async function setupSchedule(
-  opts: ScheduleOptions,
-  platform: SchedulePlatform,
-): Promise<SetupScheduleResult> {
-  const dryRun = Boolean(opts.dryRun);
-  const action = resolveAction(opts);
-  const filesToProcess = setupPlan(platform, opts);
-
-  const files: ScheduledFile[] = [];
-
-  if (action === "status") {
-    for (const file of filesToProcess) {
-      files.push({ path: file.path, exists: await exists(file.path) });
-    }
-    return { platform, action, files, dryRun };
-  }
-
-  if (action === "remove") {
-    for (const file of filesToProcess) {
-      await removeFileIfExists(file.path, dryRun);
-    }
-    for (const file of filesToProcess) {
-      files.push({ path: file.path, exists: await exists(file.path) });
-    }
-    return { platform, action, files, dryRun };
-  }
-
-  for (const file of filesToProcess) {
-    await writeIfNeeded(file.path, file.content, dryRun);
-    files.push({
-      path: file.path,
-      exists: await exists(file.path),
-      content: file.content,
-    });
-  }
-  return { platform, action, files, dryRun };
-}

package/src/consolidation/scheduler/systemd.ts

@@ -1,78 +0,0 @@
-import os from "node:os";
-import path from "node:path";
-
-import type { ScheduleOptions } from "./types.js";
-
-export const SYSTEMD_UNIT_NAME = "dev.pi.memory-consolidate";
-export const SYSTEMD_SERVICE_FILE = `${SYSTEMD_UNIT_NAME}.service`;
-export const SYSTEMD_TIMER_FILE = `${SYSTEMD_UNIT_NAME}.timer`;
-
-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 pad2(value: number, max: number): string {
-  return String(Math.max(0, Math.min(max, Math.trunc(value)))).padStart(2, "0");
-}
-
-function buildExecStart(opts: ScheduleOptions): string {
-  return commandArgs(opts).join(" ");
-}
-
-export function systemdServicePath(): string {
-  return path.join(
-    os.homedir(),
-    ".config",
-    "systemd",
-    "user",
-    SYSTEMD_SERVICE_FILE,
-  );
-}
-
-export function systemdTimerPath(): string {
-  return path.join(
-    os.homedir(),
-    ".config",
-    "systemd",
-    "user",
-    SYSTEMD_TIMER_FILE,
-  );
-}
-
-export function buildSystemdService(opts: ScheduleOptions): string {
-  return [
-    `[Unit]`,
-    `Description=Pi Memory Consolidation`,
-    ``,
-    `[Service]`,
-    `Type=oneshot`,
-    `ExecStart=${buildExecStart(opts)}`,
-    `StandardOutput=append:${opts.logPath}`,
-    `StandardError=append:${opts.logPath}`,
-    ``,
-  ].join("\n");
-}
-
-export function buildSystemdTimer(opts: ScheduleOptions): string {
-  const minute = pad2(opts.minute, 59);
-  const hour = pad2(opts.hour, 23);
-  return [
-    `[Unit]`,
-    `Description=Runs Pi memory consolidation on a daily schedule`,
-    ``,
-    `[Timer]`,
-    `Persistent=true`,
-    `OnCalendar=*-*-* ${hour}:${minute}:00`,
-    `Unit=${SYSTEMD_UNIT_NAME}.service`,
-    ``,
-    `[Install]`,
-    `WantedBy=timers.target`,
-    ``,
-  ].join("\n");
-}

package/src/consolidation/scheduler/types.ts

@@ -1,27 +0,0 @@
-export type SchedulePlatform = "darwin" | "linux";
-
-export interface ScheduleOptions {
-  hour: number;
-  minute: number;
-  logPath: string;
-  commandPath?: string;
-  npxPath?: string;
-  dryRun?: boolean;
-  remove?: boolean;
-  status?: boolean;
-}
-
-export type ScheduleAction = "write" | "remove" | "status";
-
-export interface ScheduledFile {
-  path: string;
-  exists: boolean;
-  content?: string;
-}
-
-export interface SetupScheduleResult {
-  platform: SchedulePlatform;
-  action: ScheduleAction;
-  files: ScheduledFile[];
-  dryRun: boolean;
-}

package/src/consolidation/scope.ts

@@ -1,58 +0,0 @@
-import { createHash } from "node:crypto";
-import fs from "node:fs";
-import path from "node:path";
-
-export type MemoryScope = "global" | `project:${string}`;
-
-const SCOPE_RE = /<!--\s*scope:([^>\s]+)\s*-->/;
-
-export function projectHash(input: string): string {
-  return createHash("sha256").update(input).digest("hex").slice(0, 12);
-}
-
-export function projectScope(projectHashValue: string | null | undefined): MemoryScope {
-  return projectHashValue ? `project:${projectHashValue}` : "global";
-}
-
-export function parseScopeComment(line: string): MemoryScope | null {
-  const raw = line.match(SCOPE_RE)?.[1]?.trim();
-  if (!raw) return null;
-  if (raw === "global") return "global";
-  if (/^project:[a-f0-9]{12}$/i.test(raw)) return raw as MemoryScope;
-  return null;
-}
-
-export function lineMatchesScope(
-  line: string,
-  allowedScopes: readonly MemoryScope[] | undefined,
-): boolean {
-  if (!allowedScopes || allowedScopes.length === 0) return true;
-  const scope = parseScopeComment(line);
-  if (!scope) return true;
-  return allowedScopes.includes(scope);
-}
-
-export function findGitRoot(startDir: string | null | undefined): string | null {
-  if (!startDir) return null;
-  let current = path.resolve(startDir);
-  for (;;) {
-    if (fs.existsSync(path.join(current, ".git"))) return current;
-    const parent = path.dirname(current);
-    if (parent === current) return null;
-    current = parent;
-  }
-}
-
-export function scopeForCwd(cwd: string | null | undefined): {
-  gitRoot: string | null;
-  projectHash: string | null;
-  scopes: MemoryScope[];
-} {
-  const gitRoot = findGitRoot(cwd);
-  const hash = gitRoot ? projectHash(gitRoot) : null;
-  return {
-    gitRoot,
-    projectHash: hash,
-    scopes: hash ? ["global", `project:${hash}`] : ["global"],
-  };
-}

package/src/consolidation/stage1/deltaExtract.ts

@@ -1,29 +0,0 @@
-import { createHash } from "node:crypto";
-
-import type { SessionTurn } from "../../trainer/sessionLoader.js";
-
-function turnHash(turn: SessionTurn): string {
-  return createHash("sha256")
-    .update(`${turn.role}\0${turn.content}`)
-    .digest("hex");
-}
-
-export function computeDeltaTurns(
-  parentTurns: SessionTurn[],
-  childTurns: SessionTurn[],
-): SessionTurn[] {
-  let forkIndex = 0;
-  for (
-    ;
-    forkIndex < parentTurns.length && forkIndex < childTurns.length;
-    forkIndex++
-  ) {
-    if (turnHash(parentTurns[forkIndex]!) !== turnHash(childTurns[forkIndex]!)) {
-      break;
-    }
-  }
-  return childTurns.slice(forkIndex).map((turn, idx) => ({
-    ...turn,
-    turnIndex: idx,
-  }));
-}

package/src/consolidation/stage1/drainQueue.ts

@@ -1,143 +0,0 @@
-import type { ConsolidationStore } from "./store.js";
-import { computeDeltaTurns } from "./deltaExtract.js";
-import { extractSessionToStage1 } from "./extractSession.js";
-import type { PendingSession } from "../types.js";
-import { loadSessionFile, type SessionTurn } from "../../trainer/sessionLoader.js";
-
-export interface DrainQueueOptions {
-  limit?: number;
-  dryRun?: boolean;
-  now?: string;
-}
-
-export interface DrainQueueReport {
-  sessionsProcessed: number;
-  sessionsSkipped: number;
-  sessionsFailed: number;
-  stage1NewRows: number;
-  dryRun: boolean;
-  details: Array<{
-    session_id: string;
-    status: "processed" | "skipped" | "failed";
-    reason?: string;
-    delta_turns?: number;
-  }>;
-}
-
-function topoSortPending(sessions: PendingSession[]): PendingSession[] {
-  const byId = new Map(sessions.map((session) => [session.session_id, session]));
-  const visited = new Set<string>();
-  const visiting = new Set<string>();
-  const out: PendingSession[] = [];
-
-  function visit(session: PendingSession): void {
-    if (visited.has(session.session_id)) return;
-    if (visiting.has(session.session_id)) {
-      out.push(session);
-      visited.add(session.session_id);
-      return;
-    }
-    visiting.add(session.session_id);
-    const parent = session.parent_session_id
-      ? byId.get(session.parent_session_id)
-      : undefined;
-    if (parent) visit(parent);
-    visiting.delete(session.session_id);
-    visited.add(session.session_id);
-    out.push(session);
-  }
-
-  for (const session of sessions) visit(session);
-  return out;
-}
-
-async function loadTurns(filePath: string): Promise<SessionTurn[] | null> {
-  const session = await loadSessionFile(filePath);
-  return session?.turns ?? null;
-}
-
-async function turnsForExtraction(
-  pending: PendingSession,
-): Promise<{ turns: SessionTurn[]; delta: boolean } | null> {
-  const childTurns = await loadTurns(pending.session_file);
-  if (!childTurns) return null;
-  if (!pending.parent_session_file) {
-    return { turns: childTurns, delta: false };
-  }
-  const parentTurns = await loadTurns(pending.parent_session_file).catch(() => null);
-  if (!parentTurns) return { turns: childTurns, delta: false };
-  return { turns: computeDeltaTurns(parentTurns, childTurns), delta: true };
-}
-
-export async function drainQueue(
-  store: ConsolidationStore,
-  opts: DrainQueueOptions = {},
-): Promise<DrainQueueReport> {
-  const dryRun = opts.dryRun ?? false;
-  const pending = topoSortPending(store.listPendingSessions(opts.limit ?? 100));
-  const report: DrainQueueReport = {
-    sessionsProcessed: 0,
-    sessionsSkipped: 0,
-    sessionsFailed: 0,
-    stage1NewRows: 0,
-    dryRun,
-    details: [],
-  };
-
-  for (const session of pending) {
-    try {
-      const loaded = await turnsForExtraction(session);
-      if (!loaded) {
-        report.sessionsSkipped++;
-        report.details.push({
-          session_id: session.session_id,
-          status: "skipped",
-          reason: "session_unreadable",
-        });
-        if (!dryRun) store.setPendingSessionStatus(session.session_id, "skipped");
-        continue;
-      }
-
-      if (loaded.delta && loaded.turns.length === 0) {
-        report.sessionsSkipped++;
-        report.details.push({
-          session_id: session.session_id,
-          status: "skipped",
-          reason: "clone_no_delta",
-          delta_turns: 0,
-        });
-        if (!dryRun) store.setPendingSessionStatus(session.session_id, "skipped");
-        continue;
-      }
-
-      const output = await extractSessionToStage1(session, loaded.turns, {
-        now: opts.now,
-      });
-      report.sessionsProcessed++;
-      report.stage1NewRows++;
-      report.details.push({
-        session_id: session.session_id,
-        status: "processed",
-        delta_turns: loaded.turns.length,
-      });
-      if (!dryRun) {
-        store.upsertStage1Output(output);
-        store.setPendingSessionStatus(
-          session.session_id,
-          output.status === "skipped" ? "skipped" : "done",
-        );
-      }
-    } catch (err) {
-      report.sessionsFailed++;
-      const message = err instanceof Error ? err.message : String(err);
-      report.details.push({
-        session_id: session.session_id,
-        status: "failed",
-        reason: message,
-      });
-      if (!dryRun) store.setPendingSessionStatus(session.session_id, "failed", message);
-    }
-  }
-
-  return report;
-}

package/src/consolidation/stage1/extractSession.ts

@@ -1,58 +0,0 @@
-import fs from "node:fs/promises";
-
-import { projectScope } from "../scope.js";
-import type { PendingSession, Stage1Output } from "../types.js";
-import type { SessionTurn } from "../../trainer/sessionLoader.js";
-
-const OPERATING_SIGNAL_RE =
-  /\b(prefer|preference|always|default|remember|convention|build command|test command)\b|(?:偏好|默认|以后|记住|约定|构建|测试命令)/i;
-
-function cleanLine(text: string): string {
-  return text.replace(/\s+/g, " ").trim();
-}
-
-function summarizeTurns(turns: SessionTurn[], max = 4): string {
-  return turns
-    .filter((turn) => turn.role === "user" || turn.role === "assistant")
-    .slice(0, max)
-    .map((turn) => `- ${turn.role}: ${cleanLine(turn.content).slice(0, 240)}`)
-    .join("\n");
-}
-
-function extractOperatingLines(turns: SessionTurn[]): string {
-  const lines: string[] = [];
-  for (const turn of turns) {
-    if (turn.role !== "user") continue;
-    const text = cleanLine(turn.content);
-    if (!OPERATING_SIGNAL_RE.test(text)) continue;
-    lines.push(`- ${text}`);
-  }
-  return lines.join("\n");
-}
-
-export async function extractSessionToStage1(
-  pending: PendingSession,
-  turns: SessionTurn[],
-  opts: { now?: string } = {},
-): Promise<Stage1Output> {
-  const generatedAt = opts.now ?? new Date().toISOString();
-  const stat = await fs.stat(pending.session_file);
-  const rawMemory = extractOperatingLines(turns);
-  const rolloutSummary = summarizeTurns(turns);
-  const hasOutput = rawMemory.trim() || rolloutSummary.trim();
-
-  return {
-    session_id: pending.session_id,
-    session_file: pending.session_file,
-    source_mtime_ms: Math.trunc(stat.mtimeMs),
-    generated_at: generatedAt,
-    raw_memory: rawMemory.trim(),
-    rollout_summary: rolloutSummary.trim(),
-    scope: projectScope(pending.project_hash),
-    status: hasOutput ? "done" : "skipped",
-    selected_for_phase2: false,
-    usage_count: 0,
-    last_usage: generatedAt,
-    error_message: null,
-  };
-}