cognitive-core 0.2.1 → 0.2.2

package/references/minimem/src/cli/commands/__tests__/conflicts.test.ts

@@ -1,141 +0,0 @@
-/**
- * Tests for conflict CLI commands and sync logging
- */
-
-import { describe, it, beforeEach, afterEach, expect } from "vitest";
-import fs from "node:fs/promises";
-import path from "node:path";
-import os from "node:os";
-
-import {
-  appendSyncLog,
-  readSyncLog,
-  getSyncLogPath,
-  type SyncLogEntry,
-} from "../conflicts.js";
-
-describe("sync logging", () => {
-  let tempDir: string;
-  let memoryDir: string;
-
-  beforeEach(async () => {
-    tempDir = await fs.mkdtemp(path.join(os.tmpdir(), "minimem-log-test-"));
-    memoryDir = path.join(tempDir, "memory");
-    await fs.mkdir(memoryDir, { recursive: true });
-    await fs.mkdir(path.join(memoryDir, ".minimem"), { recursive: true });
-  });
-
-  afterEach(async () => {
-    try {
-      await fs.rm(tempDir, { recursive: true, force: true });
-    } catch {
-      // Ignore cleanup errors
-    }
-  });
-
-  describe("appendSyncLog", () => {
-    it("should create log file if not exists", async () => {
-      const entry: SyncLogEntry = {
-        timestamp: new Date().toISOString(),
-        operation: "push",
-        result: "success",
-        pushed: 3,
-      };
-
-      await appendSyncLog(memoryDir, entry);
-
-      const logPath = getSyncLogPath(memoryDir);
-      const exists = await fs.access(logPath).then(() => true).catch(() => false);
-      expect(exists).toBeTruthy();
-    });
-
-    it("should append multiple entries", async () => {
-      const entry1: SyncLogEntry = {
-        timestamp: new Date().toISOString(),
-        operation: "push",
-        result: "success",
-        pushed: 2,
-      };
-
-      const entry2: SyncLogEntry = {
-        timestamp: new Date().toISOString(),
-        operation: "pull",
-        result: "success",
-        pulled: 3,
-      };
-
-      await appendSyncLog(memoryDir, entry1);
-      await appendSyncLog(memoryDir, entry2);
-
-      const entries = await readSyncLog(memoryDir);
-      expect(entries.length).toBe(2);
-      expect(entries[0].operation).toBe("push");
-      expect(entries[1].operation).toBe("pull");
-    });
-
-    it("should store error messages", async () => {
-      const entry: SyncLogEntry = {
-        timestamp: new Date().toISOString(),
-        operation: "push",
-        result: "failure",
-        errors: ["File not found", "Permission denied"],
-      };
-
-      await appendSyncLog(memoryDir, entry);
-
-      const entries = await readSyncLog(memoryDir);
-      expect(entries.length).toBe(1);
-      expect(entries[0].errors).toEqual(["File not found", "Permission denied"]);
-    });
-
-    it("should record conflict count", async () => {
-      const entry: SyncLogEntry = {
-        timestamp: new Date().toISOString(),
-        operation: "push",
-        result: "partial",
-        pushed: 2,
-        conflicts: 1,
-      };
-
-      await appendSyncLog(memoryDir, entry);
-
-      const entries = await readSyncLog(memoryDir);
-      expect(entries[0].conflicts).toBe(1);
-      expect(entries[0].result).toBe("partial");
-    });
-  });
-
-  describe("readSyncLog", () => {
-    it("should return empty array when no log exists", async () => {
-      const entries = await readSyncLog(memoryDir);
-      expect(entries).toEqual([]);
-    });
-
-    it("should parse JSONL format", async () => {
-      const logPath = getSyncLogPath(memoryDir);
-      const entries = [
-        { timestamp: "2024-01-01T10:00:00Z", operation: "push", result: "success", pushed: 1 },
-        { timestamp: "2024-01-01T11:00:00Z", operation: "pull", result: "success", pulled: 2 },
-      ];
-
-      await fs.mkdir(path.dirname(logPath), { recursive: true });
-      await fs.writeFile(
-        logPath,
-        entries.map((e) => JSON.stringify(e)).join("\n") + "\n"
-      );
-
-      const read = await readSyncLog(memoryDir);
-      expect(read.length).toBe(2);
-      expect(read[0].pushed).toBe(1);
-      expect(read[1].pulled).toBe(2);
-    });
-  });
-
-  describe("getSyncLogPath", () => {
-    it("should return path in .minimem directory", () => {
-      const logPath = getSyncLogPath(memoryDir);
-      expect(logPath.includes(".minimem")).toBeTruthy();
-      expect(logPath.endsWith("sync.log")).toBeTruthy();
-    });
-  });
-});

package/references/minimem/src/cli/commands/append.ts

@@ -1,76 +0,0 @@
-/**
- * minimem append - Quick append to today's daily log
- */
-
-import { Minimem } from "../../minimem.js";
-import {
-  resolveMemoryDir,
-  exitWithError,
-  loadConfig,
-  buildMinimemConfig,
-  isInitialized,
-  formatPath,
-} from "../config.js";
-
-export type AppendOptions = {
-  dir?: string;
-  global?: boolean;
-  file?: string;
-  provider?: string;
-  session?: string;
-  sessionSource?: string;
-};
-
-export async function append(
-  text: string,
-  options: AppendOptions,
-): Promise<void> {
-  const memoryDir = resolveMemoryDir({ dir: options.dir, global: options.global });
-
-  // Check if initialized
-  if (!(await isInitialized(memoryDir))) {
-    exitWithError(
-      `${formatPath(memoryDir)} is not initialized.`,
-      `Run: minimem init${options.dir ? ` ${options.dir}` : ""}`
-    );
-  }
-
-  // Add session marker if explicit session provided
-  let finalText = text;
-  if (options.session) {
-    const timestamp = new Date().toISOString();
-    const sourceInfo = options.sessionSource ? ` source=${options.sessionSource}` : "";
-    finalText = `<!-- ${timestamp} session=${options.session}${sourceInfo} -->\n${text}`;
-  }
-
-  // Load config and create Minimem instance
-  const cliConfig = await loadConfig(memoryDir);
-  const config = buildMinimemConfig(memoryDir, cliConfig, {
-    provider: options.provider,
-    watch: false,
-  });
-
-  let minimem: Minimem | null = null;
-
-  try {
-    minimem = await Minimem.create(config);
-
-    let targetPath: string;
-
-    if (options.file) {
-      // Append to specific file
-      targetPath = options.file;
-      await minimem.appendFile(targetPath, finalText);
-    } else {
-      // Append to today's daily log
-      targetPath = await minimem.appendToday(finalText);
-    }
-
-    console.log(`Appended to ${targetPath}`);
-    if (options.session) {
-      console.log(`  Session: ${options.session}`);
-    }
-  } finally {
-    minimem?.close();
-  }
-}

package/references/minimem/src/cli/commands/config.ts

@@ -1,262 +0,0 @@
-/**
- * minimem config - View and manage configuration
- */
-
-import {
-  resolveMemoryDir,
-  exitWithError,
-  loadConfig,
-  loadGlobalConfig,
-  loadXdgConfig,
-  saveConfig,
-  saveXdgConfig,
-  getConfigPath,
-  getGlobalConfigPath,
-  getXdgConfigPath,
-  mergeConfig,
-  getDefaultConfig,
-  getSyncConfig,
-  isInitialized,
-  formatPath,
-  type CliConfig,
-  type GlobalConfig,
-} from "../config.js";
-
-export type ConfigOptions = {
-  dir?: string;
-  global?: boolean;
-  xdgGlobal?: boolean;
-  json?: boolean;
-  set?: string;
-  unset?: string;
-};
-
-export async function config(options: ConfigOptions): Promise<void> {
-  // Handle --set and --unset
-  if (options.set || options.unset) {
-    await handleConfigEdit(options);
-    return;
-  }
-
-  // Show config
-  await showConfig(options);
-}
-
-async function showConfig(options: ConfigOptions): Promise<void> {
-  const memoryDir = resolveMemoryDir({ dir: options.dir, global: options.global });
-
-  if (!(await isInitialized(memoryDir))) {
-    exitWithError(`${formatPath(memoryDir)} is not initialized.`);
-  }
-
-  // Load configs
-  const globalConfig = await loadGlobalConfig();
-  const xdgConfig = await loadXdgConfig();
-  const localConfig = await loadConfig(memoryDir);
-  const mergedConfig = mergeConfig(localConfig);
-  const syncConfig = await getSyncConfig(memoryDir);
-  const defaults = getDefaultConfig();
-
-  if (options.json) {
-    console.log(JSON.stringify({
-      effective: mergedConfig,
-      local: localConfig,
-      global: globalConfig,
-      xdgGlobal: xdgConfig,
-      syncConfig,
-      defaults,
-    }, null, 2));
-    return;
-  }
-
-  console.log("Minimem Configuration");
-  console.log("=====================");
-  console.log();
-
-  console.log("Config Files:");
-  console.log(`  XDG Global:    ${formatPath(getXdgConfigPath())}`);
-  console.log(`  Legacy Global: ${formatPath(getGlobalConfigPath())}`);
-  console.log(`  Local:         ${formatPath(getConfigPath(memoryDir))}`);
-  console.log();
-
-  console.log("Effective Configuration:");
-  console.log("(merged from defaults → xdg global → legacy global → local)");
-  console.log();
-
-  printConfigSection("Embedding", {
-    "provider": mergedConfig.embedding?.provider,
-    "model": mergedConfig.embedding?.model || "(provider default)",
-    "fallback": mergedConfig.embedding?.fallback || "none",
-  });
-
-  printConfigSection("Hybrid Search", {
-    "enabled": mergedConfig.hybrid?.enabled,
-    "vectorWeight": mergedConfig.hybrid?.vectorWeight,
-    "textWeight": mergedConfig.hybrid?.textWeight,
-  });
-
-  printConfigSection("Query Defaults", {
-    "maxResults": mergedConfig.query?.maxResults,
-    "minScore": mergedConfig.query?.minScore,
-  });
-
-  printConfigSection("Chunking", {
-    "tokens": mergedConfig.chunking?.tokens,
-    "overlap": mergedConfig.chunking?.overlap,
-  });
-
-  printConfigSection("Sync (Local)", {
-    "enabled": syncConfig.enabled,
-    "path": syncConfig.path || "(not configured)",
-    "include": syncConfig.include.join(", "),
-    "exclude": syncConfig.exclude.length > 0 ? syncConfig.exclude.join(", ") : "(none)",
-  });
-
-  printConfigSection("Sync (Global)", {
-    "centralRepo": syncConfig.centralRepo || "(not configured)",
-    "conflictStrategy": syncConfig.conflictStrategy,
-    "autoSync": syncConfig.autoSync,
-    "autoCommit": syncConfig.autoCommit,
-    "mergeResolver": syncConfig.mergeResolver || "(default)",
-  });
-
-  console.log();
-  console.log("To modify configuration:");
-  console.log("  minimem config --set embedding.provider=openai");
-  console.log("  minimem config --set sync.enabled=true");
-  console.log("  minimem config --set sync.path=myproject/");
-  console.log();
-  console.log("Global sync settings (use --xdg-global flag):");
-  console.log("  minimem config --xdg-global --set centralRepo=~/memories-repo");
-  console.log("  minimem config --xdg-global --set sync.conflictStrategy=merge");
-}
-
-function printConfigSection(title: string, values: Record<string, unknown>): void {
-  console.log(`  ${title}:`);
-  for (const [key, value] of Object.entries(values)) {
-    const displayValue = value === undefined ? "(default)" : String(value);
-    console.log(`    ${key}: ${displayValue}`);
-  }
-}
-
-async function handleConfigEdit(options: ConfigOptions): Promise<void> {
-  // Handle XDG global config edits
-  if (options.xdgGlobal) {
-    await handleXdgConfigEdit(options);
-    return;
-  }
-
-  const memoryDir = resolveMemoryDir({ dir: options.dir, global: options.global });
-  const configPath = getConfigPath(memoryDir);
-
-  if (!(await isInitialized(memoryDir))) {
-    exitWithError(`${formatPath(memoryDir)} is not initialized.`);
-  }
-
-  // Load current config (just the local file, not merged)
-  const currentConfig = await loadConfigFile(configPath);
-
-  if (options.set) {
-    const [keyPath, value] = options.set.split("=");
-    if (!keyPath || value === undefined) {
-      exitWithError(
-        "--set requires format: key.path=value",
-        "Example: --set embedding.provider=openai"
-      );
-    }
-
-    const newConfig = setConfigValue(currentConfig, keyPath, parseValue(value));
-    await saveConfig(memoryDir, newConfig);
-    console.log(`Set ${keyPath}=${value} in ${formatPath(configPath)}`);
-  }
-
-  if (options.unset) {
-    const keyPath = options.unset;
-    const newConfig = unsetConfigValue(currentConfig, keyPath);
-    await saveConfig(memoryDir, newConfig);
-    console.log(`Unset ${keyPath} in ${formatPath(configPath)}`);
-  }
-}
-
-async function handleXdgConfigEdit(options: ConfigOptions): Promise<void> {
-  const configPath = getXdgConfigPath();
-  const currentConfig = await loadXdgConfig();
-
-  if (options.set) {
-    const [keyPath, value] = options.set.split("=");
-    if (!keyPath || value === undefined) {
-      exitWithError(
-        "--set requires format: key.path=value",
-        "Example: --set centralRepo=~/memories-repo"
-      );
-    }
-
-    const newConfig = setConfigValue(currentConfig as Record<string, unknown>, keyPath, parseValue(value)) as GlobalConfig;
-    await saveXdgConfig(newConfig);
-    console.log(`Set ${keyPath}=${value} in ${formatPath(configPath)}`);
-  }
-
-  if (options.unset) {
-    const keyPath = options.unset;
-    const newConfig = unsetConfigValue(currentConfig as Record<string, unknown>, keyPath) as GlobalConfig;
-    await saveXdgConfig(newConfig);
-    console.log(`Unset ${keyPath} in ${formatPath(configPath)}`);
-  }
-}
-
-async function loadConfigFile(configPath: string): Promise<CliConfig> {
-  const fs = await import("node:fs/promises");
-  try {
-    const content = await fs.readFile(configPath, "utf-8");
-    return JSON.parse(content) as CliConfig;
-  } catch {
-    return {};
-  }
-}
-
-function parseValue(value: string): unknown {
-  // Try to parse as JSON (for booleans, numbers, etc.)
-  try {
-    return JSON.parse(value);
-  } catch {
-    // Return as string
-    return value;
-  }
-}
-
-function setConfigValue<T extends Record<string, unknown>>(config: T, keyPath: string, value: unknown): T {
-  const parts = keyPath.split(".");
-  const result = { ...config } as Record<string, unknown>;
-  let current: Record<string, unknown> = result;
-
-  for (let i = 0; i < parts.length - 1; i++) {
-    const key = parts[i];
-    if (!(key in current) || typeof current[key] !== "object") {
-      current[key] = {};
-    } else {
-      current[key] = { ...(current[key] as Record<string, unknown>) };
-    }
-    current = current[key] as Record<string, unknown>;
-  }
-
-  current[parts[parts.length - 1]] = value;
-  return result as T;
-}
-
-function unsetConfigValue<T extends Record<string, unknown>>(config: T, keyPath: string): T {
-  const parts = keyPath.split(".");
-  const result = { ...config } as Record<string, unknown>;
-  let current: Record<string, unknown> = result;
-
-  for (let i = 0; i < parts.length - 1; i++) {
-    const key = parts[i];
-    if (!(key in current) || typeof current[key] !== "object") {
-      return result as T; // Path doesn't exist
-    }
-    current[key] = { ...(current[key] as Record<string, unknown>) };
-    current = current[key] as Record<string, unknown>;
-  }
-
-  delete current[parts[parts.length - 1]];
-  return result as T;
-}