@brianmichel/pi-noodle 0.1.0

package/src/commands/review.ts

@@ -0,0 +1,291 @@
+import { memoryService } from "../memory/runtime.ts";
+import type { MemoryRecord } from "../memory/types.ts";
+import { describeError } from "../utils.ts";
+import type { CtxUi } from "./ui.ts";
+
+type PendingCandidate = ReturnType<typeof memoryService.listPendingCandidates>[number];
+
+type ReviewService = {
+  list: typeof memoryService.list;
+  delete: typeof memoryService.delete;
+  listPendingCandidates: typeof memoryService.listPendingCandidates;
+  dismissPendingCandidate: typeof memoryService.dismissPendingCandidate;
+  promotePendingCandidate: typeof memoryService.promotePendingCandidate;
+};
+
+const SAVED_PREFIX = "[s";
+const PENDING_PREFIX = "[p";
+const ACTION_SAVE_ALL = "Save all pending candidates";
+const ACTION_DELETE_ALL = "Delete all listed items";
+const ACTION_DONE = "Exit review";
+const ACTION_BACK = "Back";
+
+export async function runReview(ui: CtxUi, service: ReviewService = memoryService): Promise<void> {
+  try {
+    let autoSaved = await listAutoSaved(service);
+    let pending = service.listPendingCandidates();
+    let deletedSaved = 0;
+    let dismissedPending = 0;
+    let savedPending = 0;
+
+    if (autoSaved.length === 0 && pending.length === 0) {
+      ui.notify("No auto-saved or pending memory candidates to review.", "info");
+      return;
+    }
+
+    ui.notify(
+      "Select an item to review it individually. [sN] means saved memory and [pN] means pending candidate. Saved items can be deleted; pending items can be saved or deleted. Bottom actions apply to the whole list.",
+      "info",
+    );
+
+    while (true) {
+      const choice = await ui.select("Review memories", buildReviewOptions(autoSaved, pending));
+
+      if (!choice || choice === ACTION_DONE) {
+        notifySummary(ui, deletedSaved, dismissedPending, savedPending);
+        return;
+      }
+
+      if (choice === ACTION_SAVE_ALL) {
+        const count = await saveAllPendingCandidates(ui, service, pending);
+        if (count === 0) continue;
+        savedPending += count;
+        pending = service.listPendingCandidates();
+        continue;
+      }
+
+      if (choice === ACTION_DELETE_ALL) {
+        const deleted = await deleteAllListedItems(ui, service, autoSaved, pending);
+        if (!deleted) continue;
+        deletedSaved += deleted.deletedSaved;
+        dismissedPending += deleted.dismissedPending;
+        autoSaved = [];
+        pending = [];
+        notifySummary(ui, deletedSaved, dismissedPending, savedPending);
+        return;
+      }
+
+      if (choice.startsWith(SAVED_PREFIX)) {
+        const selected = selectByPrefix(choice, autoSaved, SAVED_PREFIX);
+        if (!selected) continue;
+
+        const action = await ui.select(
+          `Saved memory ${choice.slice(0, choice.indexOf(" "))}`,
+          ["Delete this saved memory", ACTION_BACK],
+        );
+        if (action !== "Delete this saved memory") continue;
+
+        const deleted = await deleteSavedMemory(ui, service, selected);
+        if (!deleted) continue;
+        autoSaved = autoSaved.filter((memory) => memory !== selected);
+        deletedSaved += 1;
+      }
+
+      if (choice.startsWith(PENDING_PREFIX)) {
+        const selected = selectByPrefix(choice, pending, PENDING_PREFIX);
+        if (!selected) continue;
+
+        const action = await ui.select(
+          `Pending candidate ${choice.slice(0, choice.indexOf(" "))}`,
+          ["Save this pending candidate", "Delete this pending candidate", ACTION_BACK],
+        );
+
+        if (action === "Save this pending candidate") {
+          const saved = await savePendingCandidate(ui, service, selected);
+          if (!saved) continue;
+          pending = pending.filter((candidate) => candidate.key !== selected.key);
+          savedPending += 1;
+          continue;
+        }
+
+        if (action !== "Delete this pending candidate") continue;
+
+        const dismissed = await dismissPendingCandidate(ui, service, selected);
+        if (!dismissed) continue;
+        pending = pending.filter((candidate) => candidate.key !== selected.key);
+        dismissedPending += 1;
+      }
+
+      if (autoSaved.length === 0 && pending.length === 0) {
+        notifySummary(ui, deletedSaved, dismissedPending, savedPending);
+        return;
+      }
+    }
+  } catch (error) {
+    ui.notify(`Review failed: ${describeError(error)}`, "error");
+  }
+}
+
+async function listAutoSaved(service: ReviewService): Promise<MemoryRecord[]> {
+  const memories = await service.list();
+  return memories
+    .filter((memory) => {
+      const source = memory.metadata.source as string | undefined;
+      return source === "heuristic" || source === "repetition" || source === "llm_extracted" || source === "consolidated";
+    })
+    .slice(0, 10);
+}
+
+function buildReviewOptions(autoSaved: MemoryRecord[], pending: PendingCandidate[]): string[] {
+  const options = [
+    ...autoSaved.map((memory, index) => formatSavedOption(memory, index)),
+    ...pending.map((candidate, index) => formatPendingOption(candidate, index)),
+  ];
+
+  if (pending.length > 0) options.push(ACTION_SAVE_ALL);
+  if (autoSaved.length > 0 || pending.length > 0) options.push(ACTION_DELETE_ALL);
+  options.push(ACTION_DONE);
+  return options;
+}
+
+function selectByPrefix<T>(choice: string, items: T[], prefix: string): T | null {
+  const index = parsePrefixedIndex(choice, prefix);
+  return index === null ? null : (items[index] ?? null);
+}
+
+function parsePrefixedIndex(choice: string, prefix: string): number | null {
+  const escapedPrefix = prefix.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  const match = choice.match(new RegExp(`^${escapedPrefix}(\\d+)\\]`));
+  if (!match) return null;
+  const value = parseInt(match[1] ?? "", 10) - 1;
+  return Number.isNaN(value) || value < 0 ? null : value;
+}
+
+function formatSavedOption(memory: MemoryRecord, index: number): string {
+  const source = memory.metadata.source ?? "?";
+  const category = memory.category ?? memory.categories[0] ?? "?";
+  const confidence = typeof memory.metadata.confidence === "number"
+    ? ` ${Math.round((memory.metadata.confidence as number) * 100)}%`
+    : "";
+  return `[s${index + 1}] ${summarize(memory.text)} (${category}, ${source}${confidence})`;
+}
+
+function formatPendingOption(candidate: PendingCandidate, index: number): string {
+  return `[p${index + 1}] ${summarize(candidate.text)} (score ${candidate.score}, seen ${candidate.count}×, ${Math.round(candidate.strongestConfidence * 100)}%)`;
+}
+
+async function savePendingCandidate(ui: CtxUi, service: ReviewService, candidate: PendingCandidate): Promise<boolean> {
+  const ok = await ui.confirm(
+    "Save pending candidate?",
+    `${candidate.text}\n\nThis promotes it from pending review into saved memory.`,
+  );
+  if (!ok) {
+    ui.notify("No changes made.", "info");
+    return false;
+  }
+
+  const saved = await service.promotePendingCandidate(candidate.key);
+  if (!saved) {
+    ui.notify("Could not save that pending candidate.", "error");
+    return false;
+  }
+
+  ui.notify(`Saved pending candidate: ${summarize(candidate.text)}`, "info");
+  return true;
+}
+
+async function saveAllPendingCandidates(ui: CtxUi, service: ReviewService, pending: PendingCandidate[]): Promise<number> {
+  const ok = await ui.confirm(
+    "Save all pending candidates?",
+    `${pending.length} pending candidate${pending.length === 1 ? "" : "s"} will be promoted into saved memory.`,
+  );
+  if (!ok) {
+    ui.notify("No changes made.", "info");
+    return 0;
+  }
+
+  let savedCount = 0;
+  for (const candidate of pending) {
+    if (await service.promotePendingCandidate(candidate.key)) {
+      savedCount += 1;
+    }
+  }
+  return savedCount;
+}
+
+async function deleteSavedMemory(ui: CtxUi, service: ReviewService, memory: MemoryRecord): Promise<boolean> {
+  const ok = await ui.confirm(
+    "Delete auto-saved memory?",
+    `${memory.text}\n\nThis removes it from saved memories.`,
+  );
+  if (!ok) {
+    ui.notify("No changes made.", "info");
+    return false;
+  }
+
+  if (memory.id) {
+    await service.delete(memory.id);
+  }
+  ui.notify(`Deleted saved memory: ${summarize(memory.text)}`, "info");
+  return true;
+}
+
+async function deleteAllListedItems(
+  ui: CtxUi,
+  service: ReviewService,
+  autoSaved: MemoryRecord[],
+  pending: PendingCandidate[],
+): Promise<{ deletedSaved: number; dismissedPending: number } | null> {
+  const ok = await ui.confirm(
+    "Delete all listed items?",
+    `${autoSaved.length} saved memor${autoSaved.length === 1 ? "y" : "ies"} and ${pending.length} pending candidate${pending.length === 1 ? "" : "s"} will be removed from this review list.`,
+  );
+  if (!ok) {
+    ui.notify("No changes made.", "info");
+    return null;
+  }
+
+  let deletedSaved = 0;
+  for (const memory of autoSaved) {
+    if (memory.id) {
+      await service.delete(memory.id);
+      deletedSaved += 1;
+    }
+  }
+
+  let dismissedPending = 0;
+  for (const candidate of pending) {
+    if (service.dismissPendingCandidate(candidate.key)) {
+      dismissedPending += 1;
+    }
+  }
+
+  ui.notify(
+    `Deleted ${deletedSaved} saved memor${deletedSaved === 1 ? "y" : "ies"} and ${dismissedPending} pending candidate${dismissedPending === 1 ? "" : "s"}.`,
+    "info",
+  );
+  return { deletedSaved, dismissedPending };
+}
+
+async function dismissPendingCandidate(ui: CtxUi, service: ReviewService, candidate: PendingCandidate): Promise<boolean> {
+  const ok = await ui.confirm(
+    "Delete pending candidate?",
+    `${candidate.text}\n\nThis removes it from the pending review queue.`,
+  );
+  if (!ok) {
+    ui.notify("No changes made.", "info");
+    return false;
+  }
+
+  service.dismissPendingCandidate(candidate.key);
+  ui.notify(`Deleted pending candidate: ${summarize(candidate.text)}`, "info");
+  return true;
+}
+
+function notifySummary(ui: CtxUi, deletedSaved: number, dismissedPending: number, savedPending: number): void {
+  if (deletedSaved === 0 && dismissedPending === 0 && savedPending === 0) {
+    ui.notify("Review finished — no changes made.", "info");
+    return;
+  }
+
+  ui.notify(
+    `Review updated: saved ${savedPending}, removed ${deletedSaved} saved, and deleted ${dismissedPending} pending candidates.`,
+    "info",
+  );
+}
+
+function summarize(text: string, max = 90): string {
+  const singleLine = text.replace(/\s+/g, " ").trim();
+  if (singleLine.length <= max) return singleLine;
+  return `${singleLine.slice(0, Math.max(0, max - 1))}…`;
+}

package/src/commands/setup.ts

@@ -0,0 +1,189 @@
+import { resolveConfig, resolveConfigPath, writeConfig } from "../config.ts";
+import { runConfigScreen } from "../config-screen.ts";
+import {
+  applyDraftDefaults,
+  createDraft,
+  type DraftConfig,
+  summarizeDraft,
+  toPartialConfig,
+  validateDraft,
+} from "../config/schema.ts";
+import { describeError } from "../utils.ts";
+import type { CtxUi } from "./ui.ts";
+
+const DB_MODE_OPTIONS = [
+  "Local   — SQLite file on disk (default)",
+  "Cloud   — Turso hosted libSQL (sync everywhere)",
+];
+
+const PROVIDER_OPTIONS = [
+  "OpenAI     — text-embedding-3-small (needs API key)",
+  "LM Studio  — local at http://localhost:1234/v1",
+  "Ollama     — local at http://localhost:11434/v1",
+  "Custom     — any /v1/embeddings endpoint",
+];
+
+const EXTRACTOR_MODE_OPTIONS = [
+  "Off — disable proactive extraction",
+  "Balanced — default tradeoff",
+  "Conservative — lower cost, higher precision",
+  "Proactive — more discovery, more review",
+];
+
+export async function runSetup(ui: CtxUi): Promise<void> {
+  try {
+    ui.notify(`Config will be saved to: ${resolveConfigPath()}`, "info");
+
+    const current = resolveConfig();
+    const screenResult = await runConfigScreen(ui, current);
+    if (screenResult) {
+      if (screenResult.cancelled) {
+        ui.notify("Setup cancelled.", "info");
+        return;
+      }
+      writeConfig(screenResult.partial);
+      ui.notify("Config saved. /reload to apply.", "info");
+      return;
+    }
+
+    const draft = await collectDraftFromPrompts(ui, createDraft(current));
+    const errors = validateDraft(draft);
+    if (errors.length > 0) {
+      ui.notify(`Setup failed: ${errors[0]}`, "error");
+      return;
+    }
+
+    const ok = await ui.confirm("Save config?", summarizeDraft(draft).join("\n"));
+    if (!ok) {
+      ui.notify("Setup cancelled.", "info");
+      return;
+    }
+
+    writeConfig(toPartialConfig(draft));
+    ui.notify("Config saved. /reload to apply.", "info");
+  } catch (error) {
+    ui.notify(`Setup failed: ${describeError(error)}`, "error");
+  }
+}
+
+async function collectDraftFromPrompts(ui: CtxUi, draft: DraftConfig): Promise<DraftConfig> {
+  const dbChoice = await ui.select("Database mode", DB_MODE_OPTIONS);
+  draft.dbMode = dbChoice?.startsWith("Cloud") ? "cloud" : "local";
+
+  if (draft.dbMode === "local") {
+    draft.dbPath = (await ui.input("Database file path", draft.dbPath)) || draft.dbPath;
+  } else {
+    draft.dbUrl = await requireInput(
+      ui,
+      "Turso database URL (libsql://…)",
+      'URL must start with "libsql://"',
+      (value) => value.startsWith("libsql://"),
+      draft.dbUrl,
+    );
+    draft.dbAuthToken = await requireInput(
+      ui,
+      "Turso auth token",
+      "Auth token is required for cloud databases",
+      (value) => value.length > 0,
+      draft.dbAuthToken,
+    );
+  }
+
+  const providerChoice = await ui.select("Embedding provider", PROVIDER_OPTIONS);
+  draft.embeddingProvider = parseProviderChoice(providerChoice ?? "");
+  applyDraftDefaults(draft);
+
+  switch (draft.embeddingProvider) {
+    case "openai":
+      draft.embeddingApiKey = await requireInput(
+        ui,
+        "OpenAI API key",
+        "API key is required for OpenAI embeddings",
+        (value) => value.length > 0,
+        draft.embeddingApiKey,
+      );
+      draft.embeddingModel = (await ui.input("Model name", draft.embeddingModel)) || draft.embeddingModel;
+      break;
+    case "lm_studio":
+      draft.embeddingBaseUrl = (await ui.input("LM Studio base URL", draft.embeddingBaseUrl)) || draft.embeddingBaseUrl;
+      break;
+    case "ollama":
+      draft.embeddingModel = await requireInput(
+        ui,
+        "Ollama embedding model",
+        "Model name is required (e.g. nomic-embed-text)",
+        (value) => value.length > 0,
+        draft.embeddingModel,
+      );
+      draft.embeddingBaseUrl = (await ui.input("Ollama base URL", draft.embeddingBaseUrl)) || draft.embeddingBaseUrl;
+      break;
+    case "custom":
+      draft.embeddingBaseUrl = await requireInput(
+        ui,
+        "Embedding base URL",
+        "Base URL is required",
+        (value) => value.length > 0,
+        draft.embeddingBaseUrl,
+      );
+      draft.embeddingModel = await requireInput(
+        ui,
+        "Model name",
+        "Model name is required",
+        (value) => value.length > 0,
+        draft.embeddingModel,
+      );
+      draft.embeddingApiKey = (await ui.input("API key (or placeholder)", draft.embeddingApiKey)) || draft.embeddingApiKey;
+      break;
+  }
+
+  const modeChoice = await ui.select("Memory mode", EXTRACTOR_MODE_OPTIONS);
+  draft.extractorMode = parseExtractorModeChoice(modeChoice ?? "");
+  applyDraftDefaults(draft);
+
+  if (draft.extractorMode !== "off") {
+    draft.extractorModel = (await ui.input(
+      "Model ID to use for extraction (leave blank to disable extraction)",
+      draft.extractorModel,
+    )) || draft.extractorModel;
+    draft.extractorTriggerEvery = (await ui.input(
+      `Extract every N turns (default ${draft.extractorTriggerEvery})`,
+      draft.extractorTriggerEvery,
+    )) || draft.extractorTriggerEvery;
+    draft.extractorDebug = await ui.confirm(
+      "Show extractor debug widget?",
+      "Enable the live extractor debug widget while developing.",
+    );
+  }
+
+  return applyDraftDefaults(draft);
+}
+
+async function requireInput(
+  ui: CtxUi,
+  prompt: string,
+  errorMessage: string,
+  validate: (value: string) => boolean,
+  defaultValue?: string,
+): Promise<string> {
+  let value = (await ui.input(prompt, defaultValue)) ?? "";
+  while (!validate(value.trim())) {
+    ui.notify(errorMessage, "error");
+    value = (await ui.input(prompt, defaultValue)) ?? "";
+  }
+  return value.trim();
+}
+
+function parseProviderChoice(choice: string): DraftConfig["embeddingProvider"] {
+  const lower = choice.toLowerCase();
+  if (lower.startsWith("openai")) return "openai";
+  if (lower.includes("lm") || lower.includes("studio")) return "lm_studio";
+  if (lower.startsWith("ollama")) return "ollama";
+  return "custom";
+}
+
+function parseExtractorModeChoice(choice: string): DraftConfig["extractorMode"] {
+  if (choice.startsWith("Off")) return "off";
+  if (choice.startsWith("Conservative")) return "conservative";
+  if (choice.startsWith("Proactive")) return "proactive";
+  return "balanced";
+}

package/src/commands/status.ts

@@ -0,0 +1,32 @@
+import { resolveConfig, resolveConfigPath } from "../config.ts";
+import { maskSecret } from "../utils.ts";
+import type { CtxUi } from "./ui.ts";
+
+export function runStatus(ui: CtxUi): void {
+  const config = resolveConfig();
+  ui.notify("─── Noodle Memory ───", "info");
+  ui.notify("Commands: /noodle remember | /noodle forget | /noodle edit | /noodle review | /noodle settings | /noodle web", "info");
+  ui.notify(`Config: ${resolveConfigPath()}`, "info");
+  ui.notify(`Database: ${config.db.mode}  ${config.db.mode === "cloud" ? (config.db.url ?? "") : config.db.path}`, "info");
+  if (config.db.mode === "cloud" && config.db.authToken) {
+    ui.notify(`Auth token: ${maskSecret(config.db.authToken)}`, "info");
+  }
+  ui.notify(
+    `Embedding: ${config.embedding.provider}  ${config.embedding.model}${config.embedding.dimensions ? `  ${config.embedding.dimensions}d` : ""}`,
+    "info",
+  );
+  ui.notify(`Endpoint: ${config.embedding.baseUrl}`, "info");
+  ui.notify(`API key: ${maskSecret(config.embedding.apiKey)}`, "info");
+
+  const extractor = config.extractor;
+  if ((extractor?.mode ?? "off") !== "off") {
+    const modelLabel = extractor?.model ?? "(none — extraction disabled)";
+    ui.notify(
+      `Memory mode: ${extractor?.mode ?? "balanced"}  ${modelLabel}  every ${extractor?.triggerEvery ?? 10} turns  debug ${extractor?.debug ? "on" : "off"}`,
+      "info",
+    );
+    return;
+  }
+
+  ui.notify("Memory mode: off", "info");
+}

package/src/commands/ui.ts

@@ -0,0 +1,14 @@
+export type CtxUi = {
+  select: (title: string, options: string[]) => Promise<string | undefined>;
+  input: (prompt: string, defaultValue?: string) => Promise<string | undefined>;
+  confirm: (title: string, message: string) => Promise<boolean>;
+  notify: (message: string, level: "info" | "error") => void;
+  custom?: <T>(
+    factory: (
+      tui: unknown,
+      theme: unknown,
+      keybindings: unknown,
+      done: (result: T) => void,
+    ) => unknown,
+  ) => Promise<T>;
+};

package/src/commands/web.ts

@@ -0,0 +1,40 @@
+import {
+  isExplorerRunning,
+  openExplorerBrowser,
+  readExplorerState,
+  spawnExplorer,
+  stopExplorer,
+} from "../web/manager.ts";
+import type { CtxUi } from "./ui.ts";
+
+export async function runWeb(ui: CtxUi, subcommand: string): Promise<void> {
+  if (subcommand.match(/web\s+stop\b/)) {
+    ui.notify(stopExplorer() ? "Memory Explorer stopped." : "Memory Explorer is not running.", "info");
+    return;
+  }
+
+  const dev = /\bdev\b/.test(subcommand);
+  const portMatch = subcommand.match(/\b(\d{2,5})\b/);
+  const port = portMatch?.[1] ? parseInt(portMatch[1], 10) : 3000;
+
+  if (isExplorerRunning()) {
+    const running = readExplorerState();
+    const activePort = running?.port ?? port;
+    openExplorerBrowser(activePort);
+    ui.notify(`Memory Explorer already running at http://localhost:${activePort}`, "info");
+    return;
+  }
+
+  const spawned = spawnExplorer(port, dev);
+  if (!spawned) {
+    ui.notify("Failed to start Memory Explorer.", "error");
+    return;
+  }
+
+  ui.notify(
+    dev
+      ? `Memory Explorer (dev) starting at http://localhost:${port} — use /noodle web stop when done`
+      : `Memory Explorer started at http://localhost:${port} — closes automatically when all tabs are closed`,
+    "info",
+  );
+}

package/src/commands.ts

@@ -0,0 +1 @@
+export { registerCommands } from "./commands/index.ts";