pi-memory-stone 0.1.1 → 0.1.3

package/src/index.ts

@@ -8,7 +8,7 @@
  *  - SQLite schema + migrations
  *  - Deterministic turn_summary and file_activity capture on agent_end
  *  - FTS5 search
- *  - /memory-status, /memory-search, /memory-last commands
+ *  - /memory-status, /memory-search, /memory-open, /memory-inject, /memory-last commands
  *  - memory_search, memory_open, memory_remember, memory_forget tools
  *  - Conservative same-project before_agent_start injection
  */
@@ -19,7 +19,8 @@ import { registerTools } from "./tools/index.js";
 import { indexSessionOnAgentEnd } from "./indexing/index.js";
 import { retrieve, buildInjectionPacket, formatInjectionForLlm } from "./retrieval/index.js";
 import { getProjectId, getConfig, clearProjectCache } from "./config/index.js";
-import { closeDb } from "./db/index.js";
+import { closeDb, getRecord, insertInjection } from "./db/index.js";
+import { getMemorySessionState, manualRecordsToRankedResults } from "./session-state/index.js";
 import { createHash } from "node:crypto";
 
 // ─── Session-scoped state ───────────────────────────────────────────
@@ -72,62 +73,54 @@ export default function (pi: ExtensionAPI) {
       const config = getConfig(ctx.cwd);
       if (!config.enabled) return;
 
-      // Check for session toggle entries before honoring the cached toggle so
-      // /memory-on can re-enable injection after /memory-off in the same session.
-      for (const entry of ctx.sessionManager.getBranch()) {
-        if (
-          entry.type === "custom" &&
-          entry.customType === "memory-stone:session-toggle"
-        ) {
-          const data = entry.data as { enabled?: boolean } | undefined;
-          if (typeof data?.enabled === "boolean") {
-            sessionEnabled = data.enabled;
-          }
-        }
-      }
+      const sessionState = getMemorySessionState(ctx.sessionManager.getBranch());
+      sessionEnabled = sessionState.enabled;
 
       if (!sessionEnabled) return;
 
       const prompt = event.prompt || "";
-      if (!prompt.trim()) return;
-
-      // Hash prompt to detect repeated injections
       const promptHash = createHash("sha256").update(prompt).digest("hex").slice(0, 12);
-
       const projectId = getProjectId(ctx.cwd);
+      const injectionMode = sessionState.injectionMode ?? config.injectionMode;
+
+      const manualRecords = sessionState.manualRefs
+        .map((ref) => getRecord(ref))
+        .filter((record): record is NonNullable<typeof record> => Boolean(record));
+      const manualResults = manualRecordsToRankedResults(manualRecords, projectId);
+      const manualRefSet = new Set(manualResults.map((r) => r.record.id));
+
+      let autoResults: ReturnType<typeof retrieve> = [];
+      if (injectionMode === "auto" && prompt.trim()) {
+        const results = retrieve(prompt, projectId, [], {
+          limit: config.maxInjectedRecords,
+          crossProjectEnabled: config.crossProjectEnabled,
+        });
+
+        autoResults = results
+          .filter((r) => !manualRefSet.has(r.record.id))
+          .filter((r) => !injectedRefsThisSession.has(r.record.id))
+          .filter((r) => r.score >= config.scoreThreshold);
+      }
 
-      // Build search query
-      const results = retrieve(prompt, projectId, [], {
-        limit: config.maxInjectedRecords,
-        crossProjectEnabled: config.crossProjectEnabled,
-      });
-
-      // Filter: skip already-injected refs
-      const newResults = results.filter((r) => !injectedRefsThisSession.has(r.record.id));
-
-      // Score threshold
-      const thresholdResults = newResults.filter((r) => r.score >= config.scoreThreshold);
-
-      if (thresholdResults.length === 0) return;
+      const selectedResults = [...manualResults, ...autoResults];
+      if (selectedResults.length === 0) return;
 
-      // Build and format injection packet
-      const packet = buildInjectionPacket(thresholdResults);
+      const packet = buildInjectionPacket(selectedResults);
       const formatted = formatInjectionForLlm(packet, config.maxInjectedTokens);
 
-      // Track injected refs (prevent feedback loop)
-      for (const r of thresholdResults) {
+      // Track only search-selected refs. Manually chosen refs are intentionally
+      // injected on every turn until /memory-clear-injected is used.
+      for (const r of autoResults) {
         injectedRefsThisSession.add(r.record.id);
       }
 
-      // Log injection to DB
-      const { insertInjection } = await import("./db/index.js");
       insertInjection({
         session_id: ctx.sessionManager.getSessionId(),
         turn_entry_id: ctx.sessionManager.getLeafId() ?? undefined,
         prompt_hash: promptHash,
-        injected_refs: thresholdResults.map((r) => r.record.id).join(","),
+        injected_refs: selectedResults.map((r) => r.record.id).join(","),
         packet: formatted,
-        reasons: thresholdResults.map((r) => r.reasons.join(";")).join(" | "),
+        reasons: selectedResults.map((r) => r.reasons.join(";")).join(" | "),
       });
 
       // Inject as a non-context audit custom entry (separate from LLM context)
@@ -156,17 +149,7 @@ export default function (pi: ExtensionAPI) {
       sessionEnabled = true;
 
       // Restore session toggle from branch
-      for (const entry of ctx.sessionManager.getBranch()) {
-        if (
-          entry.type === "custom" &&
-          entry.customType === "memory-stone:session-toggle"
-        ) {
-          const data = entry.data as { enabled?: boolean } | undefined;
-          if (typeof data?.enabled === "boolean") {
-            sessionEnabled = data.enabled;
-          }
-        }
-      }
+      sessionEnabled = getMemorySessionState(ctx.sessionManager.getBranch()).enabled;
 
       // Clear project ID cache on session change
       clearProjectCache();

package/src/portable/index.ts

@@ -0,0 +1,204 @@
+/**
+ * Portable export/import/backup helpers for memory records.
+ */
+
+import { copyFileSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname, isAbsolute, resolve } from "node:path";
+import { getDb, getDbPath, listRecords, upsertRecord, type RecordRow } from "../db/index.js";
+import { SCHEMA_VERSION, RECORD_KINDS, RECORD_SCOPES, RECORD_STATUSES, type RecordKind, type RecordScope, type RecordStatus } from "../db/schema.js";
+
+export type ExportFormat = "json" | "md";
+
+export interface PortableMemoryRecord {
+  id: string;
+  kind: RecordKind;
+  scope: RecordScope;
+  project_id: string | null;
+  text: string;
+  tags: string | null;
+  status: RecordStatus;
+  confidence: number;
+  importance: number;
+  created_at: number;
+  updated_at: number;
+  superseded_by: string | null;
+  derived_from_memory_refs: string | null;
+}
+
+export interface PortableMemoryExport {
+  format: "pi-memory-stone-export";
+  version: 1;
+  exported_at: string;
+  schema_version: number;
+  records: PortableMemoryRecord[];
+}
+
+export interface ImportOptions {
+  /** Remap project-scoped records to this project id. Use undefined to preserve exported project ids. */
+  projectId?: string | null;
+  /** Force every imported record into a scope. */
+  scopeOverride?: RecordScope;
+}
+
+export interface ImportResult {
+  imported: number;
+  skipped: number;
+  ids: string[];
+}
+
+export function buildMemoryExport(includeInactive = false): PortableMemoryExport {
+  return {
+    format: "pi-memory-stone-export",
+    version: 1,
+    exported_at: new Date().toISOString(),
+    schema_version: SCHEMA_VERSION,
+    records: listRecords({ includeInactive }).map(toPortableRecord),
+  };
+}
+
+export function exportMemory(format: ExportFormat, includeInactive = false): string {
+  const payload = buildMemoryExport(includeInactive);
+  if (format === "json") {
+    return JSON.stringify(payload, null, 2) + "\n";
+  }
+
+  return exportMarkdown(payload);
+}
+
+export function writeMemoryExport(path: string, format: ExportFormat, includeInactive = false): number {
+  const payload = buildMemoryExport(includeInactive);
+  const content = format === "json" ? JSON.stringify(payload, null, 2) + "\n" : exportMarkdown(payload);
+  mkdirSync(dirname(path), { recursive: true });
+  writeFileSync(path, content, "utf8");
+  return payload.records.length;
+}
+
+export function importMemoryJsonFile(path: string, options: ImportOptions = {}): ImportResult {
+  const raw = readFileSync(path, "utf8");
+  return importMemoryJson(raw, options);
+}
+
+export function importMemoryJson(raw: string, options: ImportOptions = {}): ImportResult {
+  const parsed = JSON.parse(raw) as Partial<PortableMemoryExport>;
+  if (parsed.format !== "pi-memory-stone-export" || parsed.version !== 1 || !Array.isArray(parsed.records)) {
+    throw new Error("Unsupported memory export file. Expected pi-memory-stone-export version 1 JSON.");
+  }
+
+  const result: ImportResult = { imported: 0, skipped: 0, ids: [] };
+  for (const candidate of parsed.records) {
+    const record = normalizePortableRecord(candidate);
+    if (!record) {
+      result.skipped += 1;
+      continue;
+    }
+
+    const scope = options.scopeOverride ?? record.scope;
+    const projectId = scope === "global" ? null : (options.projectId !== undefined ? options.projectId : record.project_id);
+    const id = upsertRecord({
+      kind: record.kind,
+      scope,
+      project_id: projectId,
+      text: record.text,
+      tags: record.tags,
+      status: record.status,
+      confidence: record.confidence,
+      importance: record.importance,
+      created_at: record.created_at,
+      updated_at: record.updated_at,
+      superseded_by: record.superseded_by,
+      derived_from_memory_refs: record.derived_from_memory_refs,
+    });
+
+    result.imported += 1;
+    result.ids.push(id);
+  }
+
+  return result;
+}
+
+export function backupMemoryDatabase(path: string): void {
+  mkdirSync(dirname(path), { recursive: true });
+  getDb().exec("PRAGMA wal_checkpoint(TRUNCATE)");
+  copyFileSync(getDbPath(), path);
+}
+
+export function defaultPortablePath(cwd: string, prefix: string, extension: string): string {
+  const stamp = new Date().toISOString().replace(/[:.]/g, "-");
+  return resolve(cwd, `${prefix}-${stamp}.${extension}`);
+}
+
+export function resolvePortablePath(cwd: string, path: string): string {
+  return isAbsolute(path) ? path : resolve(cwd, path);
+}
+
+function toPortableRecord(row: RecordRow): PortableMemoryRecord {
+  return {
+    id: row.id,
+    kind: row.kind,
+    scope: row.scope,
+    project_id: row.project_id,
+    text: row.text,
+    tags: row.tags,
+    status: row.status,
+    confidence: row.confidence,
+    importance: row.importance,
+    created_at: row.created_at,
+    updated_at: row.updated_at,
+    superseded_by: row.superseded_by,
+    derived_from_memory_refs: row.derived_from_memory_refs,
+  };
+}
+
+function exportMarkdown(payload: PortableMemoryExport): string {
+  const lines: string[] = [];
+  lines.push("# Memory Stone Export");
+  lines.push("");
+  lines.push(`Exported: ${payload.exported_at}`);
+  lines.push(`Records: ${payload.records.length}`);
+  lines.push("");
+
+  for (const record of payload.records) {
+    lines.push(`## [${record.kind}] ${record.id}`);
+    lines.push("");
+    lines.push(`- Scope: ${record.scope}`);
+    lines.push(`- Project: ${record.project_id ?? "global"}`);
+    lines.push(`- Status: ${record.status}`);
+    lines.push(`- Importance: ${record.importance}`);
+    lines.push(`- Created: ${new Date(record.created_at).toISOString()}`);
+    if (record.tags) lines.push(`- Tags: ${record.tags}`);
+    lines.push("");
+    lines.push(record.text);
+    lines.push("");
+  }
+
+  return lines.join("\n");
+}
+
+function normalizePortableRecord(candidate: unknown): PortableMemoryRecord | null {
+  if (!candidate || typeof candidate !== "object") return null;
+  const r = candidate as Record<string, unknown>;
+  if (typeof r.text !== "string" || r.text.trim() === "") return null;
+  if (!isStringMember(r.kind, RECORD_KINDS)) return null;
+  if (!isStringMember(r.scope, RECORD_SCOPES)) return null;
+  if (!isStringMember(r.status, RECORD_STATUSES)) return null;
+
+  return {
+    id: typeof r.id === "string" ? r.id : "",
+    kind: r.kind,
+    scope: r.scope,
+    project_id: typeof r.project_id === "string" ? r.project_id : null,
+    text: r.text,
+    tags: typeof r.tags === "string" ? r.tags : null,
+    status: r.status,
+    confidence: typeof r.confidence === "number" ? r.confidence : 1,
+    importance: typeof r.importance === "number" ? r.importance : 0.5,
+    created_at: typeof r.created_at === "number" ? r.created_at : Date.now(),
+    updated_at: typeof r.updated_at === "number" ? r.updated_at : Date.now(),
+    superseded_by: typeof r.superseded_by === "string" ? r.superseded_by : null,
+    derived_from_memory_refs: typeof r.derived_from_memory_refs === "string" ? r.derived_from_memory_refs : null,
+  };
+}
+
+function isStringMember<T extends readonly string[]>(value: unknown, allowed: T): value is T[number] {
+  return typeof value === "string" && (allowed as readonly string[]).includes(value);
+}

package/src/session-state/index.ts

@@ -0,0 +1,88 @@
+import type { RecordRow } from "../db/index.js";
+import type { RankedResult } from "../retrieval/index.js";
+
+export type InjectionMode = "auto" | "manual";
+
+export const SESSION_TOGGLE_ENTRY = "memory-stone:session-toggle";
+export const INJECTION_MODE_ENTRY = "memory-stone:injection-mode";
+export const MANUAL_INJECTION_ENTRY = "memory-stone:manual-injection";
+
+export interface MemorySessionState {
+  enabled: boolean;
+  injectionMode?: InjectionMode;
+  manualRefs: string[];
+}
+
+export function isInjectionMode(value: unknown): value is InjectionMode {
+  return value === "auto" || value === "manual";
+}
+
+export function getMemorySessionState(branch: unknown[]): MemorySessionState {
+  let enabled = true;
+  let injectionMode: InjectionMode | undefined;
+  let manualRefs: string[] = [];
+
+  for (const entry of branch) {
+    if (!isCustomEntry(entry)) continue;
+
+    if (entry.customType === SESSION_TOGGLE_ENTRY) {
+      const data = entry.data as { enabled?: unknown } | undefined;
+      if (typeof data?.enabled === "boolean") {
+        enabled = data.enabled;
+      }
+      continue;
+    }
+
+    if (entry.customType === INJECTION_MODE_ENTRY) {
+      const data = entry.data as { mode?: unknown } | undefined;
+      if (isInjectionMode(data?.mode)) {
+        injectionMode = data.mode;
+      }
+      continue;
+    }
+
+    if (entry.customType === MANUAL_INJECTION_ENTRY) {
+      const data = entry.data as { action?: unknown; refs?: unknown } | undefined;
+      if (data?.action === "clear") {
+        manualRefs = [];
+      } else if (data?.action === "add" && Array.isArray(data.refs)) {
+        for (const ref of data.refs) {
+          if (typeof ref === "string" && ref.trim() && !manualRefs.includes(ref)) {
+            manualRefs.push(ref);
+          }
+        }
+      }
+    }
+  }
+
+  return { enabled, injectionMode, manualRefs };
+}
+
+export function parseRefArgs(args: string): string[] {
+  return (args ?? "")
+    .trim()
+    .split(/\s+/)
+    .map((part) => part.trim())
+    .filter((part) => part.length > 0 && !part.startsWith("--"));
+}
+
+export function isRecordVisibleInProject(record: RecordRow, currentProjectId: string | null): boolean {
+  return record.scope === "global" || record.project_id === null || record.project_id === currentProjectId;
+}
+
+export function manualRecordsToRankedResults(
+  records: RecordRow[],
+  currentProjectId: string | null,
+): RankedResult[] {
+  return records
+    .filter((record) => record.status === "active" && isRecordVisibleInProject(record, currentProjectId))
+    .map((record) => ({
+      record,
+      score: Number.POSITIVE_INFINITY,
+      reasons: ["manual-ref"],
+    }));
+}
+
+function isCustomEntry(entry: unknown): entry is { type?: string; customType?: string; data?: unknown } {
+  return typeof entry === "object" && entry !== null && (entry as { type?: unknown }).type === "custom";
+}

package/test/indexing.test.ts

@@ -1,97 +0,0 @@
-/**
- * Tests for incremental session indexing.
- */
-
-import { describe, it, beforeEach, after } from "node:test";
-import assert from "node:assert/strict";
-import { existsSync, unlinkSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { indexSessionOnAgentEnd } from "../src/indexing/index.js";
-import { closeDb, getDb, getDbPath } from "../src/db/index.js";
-
-const testMemoryDir = mkdtempSync(join(tmpdir(), "pi-memory-stone-indexing-"));
-process.env.PI_MEMORY_STONE_DB_PATH = join(testMemoryDir, "memory.db");
-
-function cleanDb() {
-  const dbPath = getDbPath();
-  closeDb();
-  for (const f of [dbPath, dbPath + "-wal", dbPath + "-shm"]) {
-    try { if (existsSync(f)) unlinkSync(f); } catch {}
-  }
-}
-
-function makeUserEntry(id: string, text: string) {
-  return {
-    type: "message",
-    id,
-    parentId: null,
-    message: {
-      role: "user",
-      content: text,
-      timestamp: Date.now(),
-    },
-  };
-}
-
-function makeAssistantEntry(id: string, text: string) {
-  return {
-    type: "message",
-    id,
-    parentId: null,
-    message: {
-      role: "assistant",
-      content: [{ type: "text", text }],
-      timestamp: Date.now(),
-    },
-  };
-}
-
-function makeContext(sessionFile: string, branch: unknown[]) {
-  return {
-    cwd: testMemoryDir,
-    sessionManager: {
-      getSessionFile: () => sessionFile,
-      getSessionId: () => "session-1",
-      getBranch: () => branch,
-      getLeafId: () => (branch.at(-1) as { id?: string } | undefined)?.id,
-    },
-  } as any;
-}
-
-describe("indexSessionOnAgentEnd", () => {
-  beforeEach(() => cleanDb());
-
-  after(() => {
-    cleanDb();
-    rmSync(testMemoryDir, { recursive: true, force: true });
-  });
-
-  it("indexes only entries after the last indexed entry when timestamps are absent", async () => {
-    const sessionFile = join(testMemoryDir, "session.jsonl");
-    writeFileSync(sessionFile, "");
-
-    const firstBranch = [
-      makeUserEntry("001", "First question"),
-      makeAssistantEntry("002", "First answer"),
-    ];
-    const first = await indexSessionOnAgentEnd(makeContext(sessionFile, firstBranch), {});
-    assert.equal(first.errors.length, 0);
-
-    const fullBranch = [
-      ...firstBranch,
-      makeUserEntry("003", "Second question"),
-      makeAssistantEntry("004", "Second answer"),
-    ];
-    const second = await indexSessionOnAgentEnd(makeContext(sessionFile, fullBranch), {});
-    assert.equal(second.errors.length, 0);
-
-    const rows = getDb()
-      .prepare("SELECT text FROM records WHERE kind = 'turn_summary' ORDER BY created_at")
-      .all() as Array<{ text: string }>;
-
-    assert.equal(rows.length, 2);
-    assert.ok(rows.some((r) => r.text.includes("First question")));
-    assert.ok(rows.some((r) => r.text.includes("Second question")));
-  });
-});