@chendpoc/pi-memory 0.1.11 → 0.1.13

package/src/consolidation/scheduler/systemd.ts

@@ -0,0 +1,78 @@
+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

@@ -0,0 +1,27 @@
+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

@@ -0,0 +1,58 @@
+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

@@ -0,0 +1,29 @@
+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

@@ -0,0 +1,143 @@
+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

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