@ulpi/cli 0.1.0

package/dist/mcp-installer-NQCGKQ23.js

@@ -0,0 +1,124 @@
+import {
+  getBinaryPath
+} from "./chunk-7LXY5UVC.js";
+import "./chunk-4VNS5WPM.js";
+
+// src/mcp-installer.ts
+import * as fs from "fs";
+import * as path from "path";
+function installMcpServer(projectDir) {
+  const settingsDir = path.join(projectDir, ".claude");
+  const settingsPath = path.join(settingsDir, "settings.local.json");
+  let settings = {};
+  if (fs.existsSync(settingsPath)) {
+    try {
+      settings = JSON.parse(fs.readFileSync(settingsPath, "utf-8"));
+    } catch {
+    }
+  }
+  const mcpServers = settings.mcpServers ?? {};
+  if (mcpServers["codemap"]) {
+    return { installed: false, message: "CodeMap MCP server already registered" };
+  }
+  const binary = getBinaryPath();
+  const parts = binary.split(" ");
+  const command = parts[0];
+  const baseArgs = parts.length > 1 ? [...parts.slice(1).map((a) => a.replace(/"/g, "")), "codemap", "serve"] : ["codemap", "serve"];
+  mcpServers["codemap"] = {
+    command,
+    args: baseArgs
+  };
+  settings.mcpServers = mcpServers;
+  fs.mkdirSync(settingsDir, { recursive: true });
+  fs.writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + "\n", "utf-8");
+  return { installed: true, message: "CodeMap MCP server registered in .claude/settings.local.json" };
+}
+function uninstallMcpServer(projectDir) {
+  const settingsPath = path.join(projectDir, ".claude", "settings.local.json");
+  if (!fs.existsSync(settingsPath)) return;
+  try {
+    const settings = JSON.parse(fs.readFileSync(settingsPath, "utf-8"));
+    const mcpServers = settings.mcpServers;
+    if (mcpServers?.["codemap"]) {
+      delete mcpServers["codemap"];
+      if (Object.keys(mcpServers).length === 0) {
+        delete settings.mcpServers;
+      }
+      fs.writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + "\n", "utf-8");
+    }
+  } catch {
+  }
+}
+function isMcpServerInstalled(projectDir) {
+  const settingsPath = path.join(projectDir, ".claude", "settings.local.json");
+  if (!fs.existsSync(settingsPath)) return false;
+  try {
+    const settings = JSON.parse(fs.readFileSync(settingsPath, "utf-8"));
+    const mcpServers = settings.mcpServers;
+    return !!mcpServers?.["codemap"];
+  } catch {
+    return false;
+  }
+}
+function installMemoryMcpServer(projectDir) {
+  const settingsDir = path.join(projectDir, ".claude");
+  const settingsPath = path.join(settingsDir, "settings.local.json");
+  let settings = {};
+  if (fs.existsSync(settingsPath)) {
+    try {
+      settings = JSON.parse(fs.readFileSync(settingsPath, "utf-8"));
+    } catch {
+    }
+  }
+  const mcpServers = settings.mcpServers ?? {};
+  if (mcpServers["memory"]) {
+    return { installed: false, message: "Memory MCP server already registered" };
+  }
+  const binary = getBinaryPath();
+  const parts = binary.split(" ");
+  const command = parts[0];
+  const baseArgs = parts.length > 1 ? [...parts.slice(1).map((a) => a.replace(/"/g, "")), "memory", "serve"] : ["memory", "serve"];
+  mcpServers["memory"] = {
+    command,
+    args: baseArgs
+  };
+  settings.mcpServers = mcpServers;
+  fs.mkdirSync(settingsDir, { recursive: true });
+  fs.writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + "\n", "utf-8");
+  return { installed: true, message: "Memory MCP server registered in .claude/settings.local.json" };
+}
+function uninstallMemoryMcpServer(projectDir) {
+  const settingsPath = path.join(projectDir, ".claude", "settings.local.json");
+  if (!fs.existsSync(settingsPath)) return;
+  try {
+    const settings = JSON.parse(fs.readFileSync(settingsPath, "utf-8"));
+    const mcpServers = settings.mcpServers;
+    if (mcpServers?.["memory"]) {
+      delete mcpServers["memory"];
+      if (Object.keys(mcpServers).length === 0) {
+        delete settings.mcpServers;
+      }
+      fs.writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + "\n", "utf-8");
+    }
+  } catch {
+  }
+}
+function isMemoryMcpServerInstalled(projectDir) {
+  const settingsPath = path.join(projectDir, ".claude", "settings.local.json");
+  if (!fs.existsSync(settingsPath)) return false;
+  try {
+    const settings = JSON.parse(fs.readFileSync(settingsPath, "utf-8"));
+    const mcpServers = settings.mcpServers;
+    return !!mcpServers?.["memory"];
+  } catch {
+    return false;
+  }
+}
+export {
+  installMcpServer,
+  installMemoryMcpServer,
+  isMcpServerInstalled,
+  isMemoryMcpServerInstalled,
+  uninstallMcpServer,
+  uninstallMemoryMcpServer
+};

package/dist/memory-J3G24QHS.js

@@ -0,0 +1,406 @@
+import "./chunk-4VNS5WPM.js";
+
+// src/commands/memory.ts
+import chalk from "chalk";
+async function runMemory(args, projectDir) {
+  const subcommand = args[0];
+  switch (subcommand) {
+    case "init":
+      return await initSubcommand(projectDir);
+    case "search":
+      return await searchSubcommand(args.slice(1), projectDir);
+    case "remember":
+      return await rememberSubcommand(args.slice(1), projectDir);
+    case "status":
+      return await statusSubcommand(projectDir);
+    case "export":
+      return await exportSubcommand(projectDir);
+    case "import":
+      return await importSubcommand(projectDir);
+    case "serve":
+      return await serveSubcommand(projectDir);
+    case "classify":
+      return await classifySubcommand(args.slice(1), projectDir);
+    case "enable":
+      return await enableSubcommand(projectDir);
+    case "disable":
+      return await disableSubcommand(projectDir);
+    default:
+      console.log(`
+Usage: ulpi memory <subcommand>
+
+Subcommands:
+  init                    Initialize memory for this project
+  search <query>          Search memories semantically
+  remember <text>         Store an explicit memory
+  status                  Show memory stats dashboard
+  export                  Push memories to git branch
+  import                  Pull memories from git branch
+  serve                   Start MCP server (stdio)
+  classify [session-id]   Run classifier on a captured session
+  enable                  Enable memory capture
+  disable                 Disable memory capture
+`.trim());
+  }
+}
+async function initSubcommand(projectDir) {
+  console.log(chalk.bold("\nAgent Memory -- Initialize\n"));
+  const { isMemoryInitialized, saveMemoryConfig, DEFAULT_MEMORY_CONFIG } = await import("./dist-R5F4MX3I.js");
+  const { projectMemoryDir } = await import("./dist-RKOGLK7R.js");
+  const fs = await import("fs");
+  if (isMemoryInitialized(projectDir)) {
+    console.log(chalk.yellow("Memory is already initialized for this project."));
+    console.log(chalk.dim(`  Path: ${projectMemoryDir(projectDir)}`));
+    return;
+  }
+  const memDir = projectMemoryDir(projectDir);
+  fs.mkdirSync(memDir, { recursive: true });
+  const config = { ...DEFAULT_MEMORY_CONFIG, enabled: true };
+  saveMemoryConfig(projectDir, config);
+  console.log(chalk.green("\u2713 Memory initialized"));
+  console.log(chalk.dim(`  Path:         ${memDir}`));
+  console.log(chalk.dim(`  Capture mode: ${config.captureMode}`));
+  console.log(chalk.dim(`  Classifier:   ${config.classifier.enabled ? "enabled" : "disabled"}`));
+  console.log(chalk.dim(`  Surface:      ${config.surfaceOnStart ? `on start (limit ${config.surfaceLimit})` : "disabled"}`));
+  const { installMemoryMcpServer } = await import("./mcp-installer-NQCGKQ23.js");
+  const mcp = installMemoryMcpServer(projectDir);
+  if (mcp.installed) {
+    console.log(chalk.green("\u2713 MCP server registered"));
+    console.log(chalk.dim("  Claude Code will auto-start the memory MCP server"));
+  } else {
+    console.log(chalk.dim(`  MCP: ${mcp.message}`));
+  }
+  console.log(chalk.dim("\nNext: memories will be captured automatically during sessions."));
+  console.log(chalk.dim('  Manual: ulpi memory remember "your insight here"'));
+  console.log(chalk.dim('  Search: ulpi memory search "query"'));
+}
+async function searchSubcommand(args, projectDir) {
+  const queryParts = [];
+  const flags = [];
+  for (const a of args) {
+    if (a.startsWith("--")) {
+      flags.push(a);
+    } else {
+      queryParts.push(a);
+    }
+  }
+  const query = queryParts.join(" ");
+  if (!query) {
+    console.log(chalk.red("Usage: ulpi memory search <query>"));
+    console.log(chalk.dim('  Example: ulpi memory search "authentication flow"'));
+    return;
+  }
+  let limit = 10;
+  const limitFlag = flags.find((f) => f.startsWith("--limit"));
+  if (limitFlag) {
+    const val = limitFlag.includes("=") ? limitFlag.split("=")[1] : args[args.indexOf(limitFlag) + 1];
+    if (val) limit = parseInt(val, 10) || 10;
+  }
+  const ora = (await import("ora")).default;
+  const spinner = ora("Searching memories...").start();
+  try {
+    const { searchMemory, isMemoryInitialized } = await import("./dist-R5F4MX3I.js");
+    if (!isMemoryInitialized(projectDir)) {
+      spinner.fail("Memory not initialized");
+      console.log(chalk.dim("Run 'ulpi memory init' first."));
+      return;
+    }
+    const result = await searchMemory(projectDir, { query, limit });
+    spinner.stop();
+    if (result.results.length === 0) {
+      console.log(chalk.yellow("No matching memories found."));
+      console.log(chalk.dim(`  Query:    "${query}"`));
+      console.log(chalk.dim(`  Duration: ${result.durationMs}ms`));
+      return;
+    }
+    console.log(chalk.bold(`
+Memory Search -- "${query}"
+`));
+    console.log(chalk.dim(`  ${result.results.length} results in ${result.durationMs}ms
+`));
+    for (let i = 0; i < result.results.length; i++) {
+      const r = result.results[i];
+      const score = (r.finalScore * 100).toFixed(1);
+      const badge = formatTypeBadge(r.entry.type);
+      const importance = formatImportance(r.entry.importance);
+      console.log(
+        chalk.cyan(`  ${i + 1}. `) + badge + " " + chalk.white(truncate(r.entry.summary, 70)) + chalk.dim(` (${score}%)`)
+      );
+      const details = [importance];
+      if (r.entry.tags.length > 0) {
+        details.push(chalk.dim(r.entry.tags.slice(0, 3).join(", ")));
+      }
+      console.log(chalk.dim(`     ${details.join(" | ")}`));
+    }
+    console.log("");
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    spinner.fail(`Search failed: ${message}`);
+  }
+}
+async function rememberSubcommand(args, projectDir) {
+  let memType = "CONTEXT";
+  let importance = "medium";
+  const textParts = [];
+  for (let i = 0; i < args.length; i++) {
+    if (args[i] === "--type" && args[i + 1]) {
+      memType = args[i + 1];
+      i++;
+    } else if (args[i].startsWith("--type=")) {
+      memType = args[i].split("=")[1];
+    } else if (args[i] === "--importance" && args[i + 1]) {
+      importance = args[i + 1];
+      i++;
+    } else if (args[i].startsWith("--importance=")) {
+      importance = args[i].split("=")[1];
+    } else if (!args[i].startsWith("--")) {
+      textParts.push(args[i]);
+    }
+  }
+  const text = textParts.join(" ");
+  if (!text) {
+    console.log(chalk.red("Usage: ulpi memory remember <text> [--type TYPE] [--importance LEVEL]"));
+    console.log(chalk.dim("\nTypes: DECISION, PATTERN, BUG_ROOT_CAUSE, PREFERENCE, CONSTRAINT, CONTEXT, LESSON, RELATIONSHIP"));
+    console.log(chalk.dim("Importance: critical, high, medium, low"));
+    console.log(chalk.dim('\nExample: ulpi memory remember "Always run tests before committing" --type PREFERENCE --importance high'));
+    return;
+  }
+  const { isMemoryInitialized } = await import("./dist-R5F4MX3I.js");
+  if (!isMemoryInitialized(projectDir)) {
+    console.log(chalk.red("Error: Memory not initialized. Run 'ulpi memory init' first."));
+    return;
+  }
+  const validTypes = ["DECISION", "PATTERN", "BUG_ROOT_CAUSE", "PREFERENCE", "CONSTRAINT", "CONTEXT", "LESSON", "RELATIONSHIP"];
+  if (!validTypes.includes(memType)) {
+    console.log(chalk.red(`Error: Invalid type "${memType}".`));
+    console.log(chalk.dim(`  Valid types: ${validTypes.join(", ")}`));
+    return;
+  }
+  const validImportance = ["critical", "high", "medium", "low"];
+  if (!validImportance.includes(importance)) {
+    console.log(chalk.red(`Error: Invalid importance "${importance}".`));
+    console.log(chalk.dim(`  Valid values: ${validImportance.join(", ")}`));
+    return;
+  }
+  const ora = (await import("ora")).default;
+  const spinner = ora("Storing memory...").start();
+  try {
+    const { generateMemoryId, rememberMemory } = await import("./dist-R5F4MX3I.js");
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const entry = {
+      id: generateMemoryId(memType, text),
+      type: memType,
+      summary: text,
+      detail: null,
+      importance,
+      tags: [],
+      relatedFiles: [],
+      source: { type: "explicit" },
+      createdAt: now,
+      updatedAt: now,
+      accessCount: 0
+    };
+    await rememberMemory(projectDir, entry);
+    spinner.succeed("Memory stored");
+    console.log(chalk.dim(`  Type:       ${memType}`));
+    console.log(chalk.dim(`  Importance: ${importance}`));
+    console.log(chalk.dim(`  ID:         ${entry.id.slice(0, 12)}...`));
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    spinner.fail(`Failed to store memory: ${message}`);
+  }
+}
+async function statusSubcommand(projectDir) {
+  const { isMemoryInitialized, getMemoryStats, isMemoryEnabled, loadMemoryConfig } = await import("./dist-R5F4MX3I.js");
+  console.log(chalk.bold("\nAgent Memory Status\n"));
+  if (!isMemoryInitialized(projectDir)) {
+    console.log(chalk.yellow("  Not initialized"));
+    console.log(chalk.dim("  Run 'ulpi memory init' to set up memory for this project.\n"));
+    return;
+  }
+  const config = loadMemoryConfig(projectDir);
+  const enabled = isMemoryEnabled(projectDir);
+  console.log(`  ${chalk.dim("Enabled:")}       ${enabled ? chalk.green("yes") : chalk.red("no")}`);
+  console.log(`  ${chalk.dim("Capture mode:")} ${config.captureMode}`);
+  console.log(`  ${chalk.dim("Classifier:")}    ${config.classifier.enabled ? chalk.green("enabled") : chalk.dim("disabled")}`);
+  console.log(`  ${chalk.dim("Surface:")}       ${config.surfaceOnStart ? `on start (limit ${config.surfaceLimit})` : "disabled"}`);
+  console.log("");
+  try {
+    const stats = await getMemoryStats(projectDir);
+    console.log(chalk.bold("  Memories"));
+    console.log(`    ${chalk.dim("Total:")}        ${stats.totalMemories}`);
+    if (Object.keys(stats.memoriesByType).length > 0) {
+      const typeEntries = Object.entries(stats.memoriesByType);
+      for (const [type, count] of typeEntries) {
+        console.log(`    ${chalk.dim(padRight(type + ":", 18))} ${count}`);
+      }
+    }
+    console.log("");
+    console.log(chalk.bold("  Activity"));
+    console.log(`    ${chalk.dim("Total accesses:")}   ${stats.totalAccesses}`);
+    console.log(`    ${chalk.dim("Sessions captured:")} ${stats.sessionsCaptured}`);
+    console.log(`    ${chalk.dim("Classified:")}        ${stats.sessionsClassified}`);
+    console.log(`    ${chalk.dim("Index size:")}        ${formatBytes(stats.indexSizeBytes)}`);
+    if (stats.lastClassifiedAt) {
+      console.log(`    ${chalk.dim("Last classified:")}  ${stats.lastClassifiedAt}`);
+    }
+    console.log("");
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    console.log(chalk.red(`  Error loading stats: ${message}`));
+  }
+}
+async function exportSubcommand(projectDir) {
+  console.log(chalk.bold("\nAgent Memory -- Export\n"));
+  const { isMemoryInitialized, exportMemories } = await import("./dist-R5F4MX3I.js");
+  if (!isMemoryInitialized(projectDir)) {
+    console.log(chalk.red("Error: Memory not initialized. Run 'ulpi memory init' first."));
+    return;
+  }
+  try {
+    const result = exportMemories(projectDir);
+    console.log(chalk.green("\u2713 Export complete"));
+    console.log(chalk.dim(`  Branch:   ${result.branchName}`));
+    console.log(chalk.dim(`  Commit:   ${result.commitSha.slice(0, 8)}`));
+    console.log(chalk.dim(`  Memories: ${result.memoriesExported}`));
+    console.log("");
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    console.log(chalk.red(`Error: ${message}`));
+  }
+}
+async function importSubcommand(projectDir) {
+  console.log(chalk.bold("\nAgent Memory -- Import\n"));
+  const { importMemories } = await import("./dist-R5F4MX3I.js");
+  try {
+    const result = importMemories(projectDir);
+    if (!result.success) {
+      console.log(chalk.yellow(`Import skipped: ${result.message}`));
+      return;
+    }
+    console.log(chalk.green("\u2713 Import complete"));
+    console.log(chalk.dim(`  Imported: ${result.memoriesImported}`));
+    console.log(chalk.dim(`  ${result.message}`));
+    console.log("");
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    console.log(chalk.red(`Error: ${message}`));
+  }
+}
+async function serveSubcommand(projectDir) {
+  const { isMemoryInitialized } = await import("./dist-R5F4MX3I.js");
+  if (!isMemoryInitialized(projectDir)) {
+    console.error(chalk.red("Error: Memory not initialized. Run 'ulpi memory init' first."));
+    process.exit(1);
+  }
+  console.error(chalk.dim("[memory-mcp] Starting MCP server..."));
+  console.error(chalk.dim(`[memory-mcp] Project: ${projectDir}`));
+  const { startMemoryMcpServer } = await import("./dist-7LHZ65GC.js");
+  await startMemoryMcpServer({ projectDir });
+}
+async function classifySubcommand(args, projectDir) {
+  const { isMemoryInitialized, listCapturedSessions, classifySession } = await import("./dist-R5F4MX3I.js");
+  if (!isMemoryInitialized(projectDir)) {
+    console.log(chalk.red("Error: Memory not initialized. Run 'ulpi memory init' first."));
+    return;
+  }
+  let sessionId = args.filter((a) => !a.startsWith("--"))[0];
+  if (!sessionId) {
+    const sessions = listCapturedSessions(projectDir);
+    if (sessions.length === 0) {
+      console.log(chalk.yellow("No captured sessions found."));
+      console.log(chalk.dim("Sessions are captured automatically at session end when memory is enabled."));
+      return;
+    }
+    const latest = sessions[sessions.length - 1];
+    sessionId = latest.sessionId;
+    console.log(chalk.dim(`Using latest session: ${sessionId}`));
+  }
+  console.log(chalk.bold(`
+Agent Memory -- Classify Session
+`));
+  console.log(chalk.dim(`  Session: ${sessionId}
+`));
+  const ora = (await import("ora")).default;
+  const spinner = ora("Starting classification...").start();
+  try {
+    const result = await classifySession(projectDir, sessionId, (progress) => {
+      const pct = progress.total > 0 ? ` (${Math.round(progress.current / progress.total * 100)}%)` : "";
+      spinner.text = `${progress.message}${pct}`;
+    });
+    spinner.succeed("Classification complete");
+    console.log(chalk.dim(`  Windows processed:  ${result.windowsProcessed}`));
+    console.log(chalk.dim(`  Memories extracted: ${result.memoriesExtracted}`));
+    console.log(chalk.dim(`  Memories stored:    ${result.memoriesStored}`));
+    console.log(chalk.dim(`  Duration:           ${(result.durationMs / 1e3).toFixed(1)}s`));
+    console.log("");
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    spinner.fail(`Classification failed: ${message}`);
+  }
+}
+async function enableSubcommand(projectDir) {
+  const { loadMemoryConfig, saveMemoryConfig, isMemoryInitialized } = await import("./dist-R5F4MX3I.js");
+  if (!isMemoryInitialized(projectDir)) {
+    console.log(chalk.red("Error: Memory not initialized. Run 'ulpi memory init' first."));
+    return;
+  }
+  const config = loadMemoryConfig(projectDir);
+  config.enabled = true;
+  saveMemoryConfig(projectDir, config);
+  console.log(chalk.green("\u2713 Memory capture enabled"));
+}
+async function disableSubcommand(projectDir) {
+  const { loadMemoryConfig, saveMemoryConfig, isMemoryInitialized } = await import("./dist-R5F4MX3I.js");
+  if (!isMemoryInitialized(projectDir)) {
+    console.log(chalk.red("Error: Memory not initialized. Run 'ulpi memory init' first."));
+    return;
+  }
+  const config = loadMemoryConfig(projectDir);
+  config.enabled = false;
+  saveMemoryConfig(projectDir, config);
+  console.log(chalk.yellow("\u2713 Memory capture disabled"));
+}
+function truncate(str, maxLen) {
+  if (str.length <= maxLen) return str;
+  return str.slice(0, maxLen - 3) + "...";
+}
+function padRight(str, len) {
+  return str.length >= len ? str : str + " ".repeat(len - str.length);
+}
+function formatBytes(bytes) {
+  if (bytes === 0) return "0 B";
+  const units = ["B", "KB", "MB", "GB"];
+  const i = Math.min(Math.floor(Math.log(bytes) / Math.log(1024)), units.length - 1);
+  const val = bytes / Math.pow(1024, i);
+  return `${val.toFixed(i === 0 ? 0 : 1)} ${units[i]}`;
+}
+var TYPE_COLORS = {
+  DECISION: chalk.magenta,
+  PATTERN: chalk.blue,
+  BUG_ROOT_CAUSE: chalk.red,
+  PREFERENCE: chalk.cyan,
+  CONSTRAINT: chalk.yellow,
+  CONTEXT: chalk.green,
+  LESSON: chalk.hex("#FFA500"),
+  RELATIONSHIP: chalk.hex("#9370DB")
+};
+function formatTypeBadge(type) {
+  const colorFn = TYPE_COLORS[type] ?? chalk.dim;
+  return colorFn(`[${type}]`);
+}
+function formatImportance(imp) {
+  switch (imp) {
+    case "critical":
+      return chalk.red("critical");
+    case "high":
+      return chalk.yellow("high");
+    case "medium":
+      return chalk.dim("medium");
+    case "low":
+      return chalk.dim("low");
+  }
+}
+export {
+  runMemory
+};

package/dist/ollama-3XCUZMZT-FYKHW4TZ.js

@@ -0,0 +1,7 @@
+import {
+  OllamaEmbedder
+} from "./chunk-KLEASXUR.js";
+import "./chunk-4VNS5WPM.js";
+export {
+  OllamaEmbedder
+};

package/dist/openai-E7G2YAHU-UYY4ZWON.js

@@ -0,0 +1,8 @@
+import {
+  OpenAIEmbedder
+} from "./chunk-2HEE5OKX.js";
+import "./chunk-7LXY5UVC.js";
+import "./chunk-4VNS5WPM.js";
+export {
+  OpenAIEmbedder
+};