@ulpi/cli 0.1.0

package/dist/config-EGAXXCGL.js

@@ -0,0 +1,127 @@
+import {
+  loadUlpiSettings,
+  saveUlpiSettings
+} from "./chunk-7LXY5UVC.js";
+import "./chunk-4VNS5WPM.js";
+
+// src/commands/config.ts
+import chalk from "chalk";
+function runConfig(args) {
+  const sub = args[0];
+  switch (sub) {
+    case "set":
+      return setConfig(args.slice(1));
+    case "get":
+      return getConfig(args.slice(1));
+    case "show":
+      return showConfig();
+    default:
+      console.log(`
+Usage: ulpi config <command>
+
+Commands:
+  set openai-key <key>       Set OpenAI API key
+  set anthropic-key <key>    Set Anthropic API key
+  set ulpi-key <key>         Set ULPI API key
+  set ulpi-url <url>         Set ULPI Cloud API URL
+  get openai-key             Show OpenAI API key (masked)
+  get anthropic-key          Show Anthropic API key (masked)
+  get ulpi-key               Show ULPI API key (masked)
+  get ulpi-url               Show ULPI Cloud API URL
+  show                       Show all settings
+`.trim());
+  }
+}
+function setConfig(args) {
+  const key = args[0];
+  const value = args[1];
+  if (!key || !value) {
+    console.error(chalk.red("Usage: ulpi config set <key> <value>"));
+    return;
+  }
+  const settings = loadUlpiSettings();
+  if (!settings.apiKeys) settings.apiKeys = {};
+  switch (key) {
+    case "openai-key":
+      settings.apiKeys.openai = stripKeyPrefix(value);
+      saveUlpiSettings(settings);
+      console.log(chalk.green(`\u2713 OpenAI API key saved to ~/.ulpi/settings.json`));
+      break;
+    case "anthropic-key":
+      settings.apiKeys.anthropic = stripKeyPrefix(value);
+      saveUlpiSettings(settings);
+      console.log(chalk.green(`\u2713 Anthropic API key saved to ~/.ulpi/settings.json`));
+      break;
+    case "ulpi-key":
+      settings.apiKeys.ulpi = stripKeyPrefix(value);
+      saveUlpiSettings(settings);
+      console.log(chalk.green(`\u2713 ULPI API key saved to ~/.ulpi/settings.json`));
+      break;
+    case "ulpi-url":
+      settings.ulpiUrl = value;
+      saveUlpiSettings(settings);
+      console.log(chalk.green(`\u2713 ULPI Cloud API URL saved to ~/.ulpi/settings.json`));
+      break;
+    default:
+      console.error(chalk.red(`Unknown config key: ${key}`));
+      console.error(chalk.dim("  Available: openai-key, anthropic-key, ulpi-key, ulpi-url"));
+  }
+}
+function getConfig(args) {
+  const key = args[0];
+  if (!key) {
+    console.error(chalk.red("Usage: ulpi config get <key>"));
+    return;
+  }
+  const settings = loadUlpiSettings();
+  switch (key) {
+    case "openai-key": {
+      const val = settings.apiKeys?.openai;
+      console.log(val ? maskKey(val) : chalk.dim("(not set)"));
+      break;
+    }
+    case "anthropic-key": {
+      const val = settings.apiKeys?.anthropic;
+      console.log(val ? maskKey(val) : chalk.dim("(not set)"));
+      break;
+    }
+    case "ulpi-key": {
+      const val = settings.apiKeys?.ulpi;
+      console.log(val ? maskKey(val) : chalk.dim("(not set)"));
+      break;
+    }
+    case "ulpi-url": {
+      const val = settings.ulpiUrl;
+      console.log(val ?? chalk.dim("(not set \u2014 default: http://localhost:10271)"));
+      break;
+    }
+    default:
+      console.error(chalk.red(`Unknown config key: ${key}`));
+  }
+}
+function showConfig() {
+  const settings = loadUlpiSettings();
+  const masked = {
+    ...settings,
+    apiKeys: {
+      openai: settings.apiKeys?.openai ? maskKey(settings.apiKeys.openai) : void 0,
+      anthropic: settings.apiKeys?.anthropic ? maskKey(settings.apiKeys.anthropic) : void 0,
+      ulpi: settings.apiKeys?.ulpi ? maskKey(settings.apiKeys.ulpi) : void 0
+    }
+  };
+  console.log(JSON.stringify(masked, null, 2));
+}
+function stripKeyPrefix(value) {
+  const eqIdx = value.indexOf("=");
+  if (eqIdx !== -1 && value.slice(0, eqIdx).match(/^[A-Z_]+$/)) {
+    return value.slice(eqIdx + 1);
+  }
+  return value;
+}
+function maskKey(key) {
+  if (key.length <= 8) return "****";
+  return key.slice(0, 4) + "..." + key.slice(-4);
+}
+export {
+  runConfig
+};

package/dist/dist-6G7JC2RA.js

@@ -0,0 +1,90 @@
+import {
+  ANNOTATION_TYPE_FEEDBACK_PREFIX,
+  ANNOTATION_TYPE_LABELS,
+  AnnotationTypeSchema,
+  BlockSchema,
+  BlockTypeSchema,
+  CaptureModeSchema,
+  ClassificationResultSchema,
+  CodemapBatchConfigSchema,
+  CodemapChunkingConfigSchema,
+  CodemapChunkingStrategySchema,
+  CodemapConfigSchema,
+  CodemapEmbeddingConfigSchema,
+  CodemapEmbeddingProviderSchema,
+  CodemapHybridConfigSchema,
+  CodemapHybridWeightsSchema,
+  CodemapSymbolTypeSchema,
+  DepgraphConfigSchema,
+  DepgraphPagerankConfigSchema,
+  DepgraphPersonalizationConfigSchema,
+  DiffChunkSchema,
+  DiffChunkTypeSchema,
+  InlineEditSchema,
+  MemoryClassifierConfigSchema,
+  MemoryConfigSchema,
+  MemoryEmbeddingConfigSchema,
+  MemoryEntrySchema,
+  MemoryImportanceSchema,
+  MemoryRankingConfigSchema,
+  MemoryRetentionConfigSchema,
+  MemorySourceSchema,
+  MemoryTypeSchema,
+  PlanSectionSchema,
+  PlanStatusSchema,
+  PriorityLevelSchema,
+  RepoInfoSchema,
+  ReviewAnnotationSchema,
+  ReviewDecisionSchema,
+  RiskLevelSchema,
+  SectionInstructionSchema,
+  SectionPrioritySchema,
+  SectionRiskSchema,
+  SectionStatusSchema
+} from "./chunk-74WVVWJ4.js";
+import "./chunk-KIKPIH6N.js";
+import "./chunk-4VNS5WPM.js";
+export {
+  ANNOTATION_TYPE_FEEDBACK_PREFIX,
+  ANNOTATION_TYPE_LABELS,
+  AnnotationTypeSchema,
+  BlockSchema,
+  BlockTypeSchema,
+  CaptureModeSchema,
+  ClassificationResultSchema,
+  CodemapBatchConfigSchema,
+  CodemapChunkingConfigSchema,
+  CodemapChunkingStrategySchema,
+  CodemapConfigSchema,
+  CodemapEmbeddingConfigSchema,
+  CodemapEmbeddingProviderSchema,
+  CodemapHybridConfigSchema,
+  CodemapHybridWeightsSchema,
+  CodemapSymbolTypeSchema,
+  DepgraphConfigSchema,
+  DepgraphPagerankConfigSchema,
+  DepgraphPersonalizationConfigSchema,
+  DiffChunkSchema,
+  DiffChunkTypeSchema,
+  InlineEditSchema,
+  MemoryClassifierConfigSchema,
+  MemoryConfigSchema,
+  MemoryEmbeddingConfigSchema,
+  MemoryEntrySchema,
+  MemoryImportanceSchema,
+  MemoryRankingConfigSchema,
+  MemoryRetentionConfigSchema,
+  MemorySourceSchema,
+  MemoryTypeSchema,
+  PlanSectionSchema,
+  PlanStatusSchema,
+  PriorityLevelSchema,
+  RepoInfoSchema,
+  ReviewAnnotationSchema,
+  ReviewDecisionSchema,
+  RiskLevelSchema,
+  SectionInstructionSchema,
+  SectionPrioritySchema,
+  SectionRiskSchema,
+  SectionStatusSchema
+};

package/dist/dist-7LHZ65GC.js

@@ -0,0 +1,418 @@
+import {
+  CallToolRequestSchema,
+  ListToolsRequestSchema,
+  Server,
+  StdioServerTransport
+} from "./chunk-JWUUVXIV.js";
+import {
+  generateMemoryId,
+  getMemoryStats,
+  listCapturedSessions,
+  listEntries,
+  loadEntry,
+  readCapturedEvents,
+  rememberMemory,
+  removeEntry,
+  searchMemory,
+  updateEntry
+} from "./chunk-6JCMYYBT.js";
+import "./chunk-DBMUNBNB.js";
+import "./chunk-NNUWU6CV.js";
+import "./chunk-YM2HV4IA.js";
+import "./chunk-74WVVWJ4.js";
+import "./chunk-KIKPIH6N.js";
+import "./chunk-2HEE5OKX.js";
+import "./chunk-KLEASXUR.js";
+import "./chunk-7LXY5UVC.js";
+import "./chunk-4VNS5WPM.js";
+
+// ../../packages/memory-mcp/dist/index.js
+var searchMemoryTool = {
+  name: "search_memory",
+  description: "Search project memories by semantic similarity. Returns memories ranked by relevance, importance, and access frequency. Memories include decisions, patterns, bug root causes, preferences, constraints, context, lessons, and relationships.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      query: { type: "string", description: "Natural language search query" },
+      type: {
+        type: "string",
+        description: "Filter by memory type",
+        enum: ["DECISION", "PATTERN", "BUG_ROOT_CAUSE", "PREFERENCE", "CONSTRAINT", "CONTEXT", "LESSON", "RELATIONSHIP"]
+      },
+      importance: {
+        type: "string",
+        description: "Filter by importance level",
+        enum: ["critical", "high", "medium", "low"]
+      },
+      limit: { type: "number", description: "Maximum results (default 10, max 50)" },
+      tags: {
+        type: "array",
+        items: { type: "string" },
+        description: "Filter by tags (matches any)"
+      },
+      since: { type: "string", description: "Only memories created after this ISO date" },
+      includeSuperseded: { type: "boolean", description: "Include superseded memories (default false)" }
+    },
+    required: ["query"]
+  }
+};
+async function handleSearchMemory(projectDir, args) {
+  const query = args.query;
+  const limit = typeof args.limit === "number" ? Math.min(Math.max(1, args.limit), 50) : 10;
+  const types = typeof args.type === "string" ? [args.type] : void 0;
+  const importance = typeof args.importance === "string" ? [args.importance] : void 0;
+  const tags = Array.isArray(args.tags) ? args.tags : void 0;
+  const since = typeof args.since === "string" ? args.since : void 0;
+  const includeSuperseded = typeof args.includeSuperseded === "boolean" ? args.includeSuperseded : void 0;
+  const result = await searchMemory(projectDir, {
+    query,
+    limit,
+    types,
+    importance,
+    tags,
+    since,
+    includeSuperseded
+  });
+  const payload = {
+    query: result.query,
+    durationMs: result.durationMs,
+    resultCount: result.results.length,
+    results: result.results.map((r) => ({
+      id: r.entry.id,
+      type: r.entry.type,
+      summary: r.entry.summary,
+      detail: r.entry.detail,
+      importance: r.entry.importance,
+      score: Math.round(r.score * 1e3) / 1e3,
+      finalScore: Math.round(r.finalScore * 1e3) / 1e3,
+      tags: r.entry.tags,
+      relatedFiles: r.entry.relatedFiles,
+      accessCount: r.entry.accessCount,
+      createdAt: r.entry.createdAt,
+      updatedAt: r.entry.updatedAt
+    })),
+    summary: result.results.length > 0 ? `Found ${result.results.length} memories for "${query}" in ${result.durationMs}ms` : `No memories found for "${query}"`
+  };
+  return {
+    content: [{ type: "text", text: JSON.stringify(payload, null, 2) }]
+  };
+}
+var saveMemoryTool = {
+  name: "save_memory",
+  description: "Save an explicit memory. Use this to record decisions, patterns, bug root causes, preferences, constraints, context, lessons, or relationships discovered during a session.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      summary: { type: "string", description: "The memory content (max 2000 chars)" },
+      type: {
+        type: "string",
+        description: "Memory type",
+        enum: ["DECISION", "PATTERN", "BUG_ROOT_CAUSE", "PREFERENCE", "CONSTRAINT", "CONTEXT", "LESSON", "RELATIONSHIP"]
+      },
+      detail: { type: "string", description: "Additional detail or context (max 10000 chars)" },
+      importance: {
+        type: "string",
+        description: "Importance level (default 'medium')",
+        enum: ["critical", "high", "medium", "low"]
+      },
+      tags: {
+        type: "array",
+        items: { type: "string" },
+        description: "Tags for categorization"
+      },
+      relatedFiles: {
+        type: "array",
+        items: { type: "string" },
+        description: "File paths related to this memory"
+      }
+    },
+    required: ["summary", "type"]
+  }
+};
+async function handleSaveMemory(projectDir, args) {
+  const summary = args.summary;
+  const type = args.type;
+  const detail = typeof args.detail === "string" ? args.detail : null;
+  const importance = typeof args.importance === "string" ? args.importance : "medium";
+  const tags = Array.isArray(args.tags) ? args.tags : [];
+  const relatedFiles = Array.isArray(args.relatedFiles) ? args.relatedFiles : [];
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const id = generateMemoryId(type, summary);
+  const entry = {
+    id,
+    type,
+    summary,
+    detail,
+    importance,
+    tags,
+    relatedFiles,
+    source: {
+      type: "explicit"
+    },
+    createdAt: now,
+    updatedAt: now,
+    accessCount: 0
+  };
+  await rememberMemory(projectDir, entry);
+  const payload = {
+    id,
+    type,
+    importance,
+    summary: summary.length > 100 ? summary.slice(0, 100) + "..." : summary,
+    message: `Memory saved successfully (id: ${id})`
+  };
+  return {
+    content: [{ type: "text", text: JSON.stringify(payload, null, 2) }]
+  };
+}
+var getTimelineTool = {
+  name: "get_timeline",
+  description: "Get a chronological timeline of memories. Returns memories sorted newest-first, optionally filtered by date and type.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      since: { type: "string", description: "Only memories created after this ISO date" },
+      type: {
+        type: "string",
+        description: "Filter by memory type",
+        enum: ["DECISION", "PATTERN", "BUG_ROOT_CAUSE", "PREFERENCE", "CONSTRAINT", "CONTEXT", "LESSON", "RELATIONSHIP"]
+      },
+      limit: { type: "number", description: "Maximum results (default 20)" }
+    }
+  }
+};
+async function handleGetTimeline(projectDir, args) {
+  const since = typeof args.since === "string" ? args.since : void 0;
+  const type = typeof args.type === "string" ? args.type : void 0;
+  const limit = typeof args.limit === "number" ? Math.min(Math.max(1, args.limit), 100) : 20;
+  let entries = listEntries(projectDir);
+  if (type) {
+    entries = entries.filter((e) => e.type === type);
+  }
+  if (since) {
+    entries = entries.filter((e) => e.createdAt >= since);
+  }
+  entries.sort((a, b) => b.createdAt.localeCompare(a.createdAt));
+  const trimmed = entries.slice(0, limit);
+  const payload = {
+    totalMatching: entries.length,
+    returned: trimmed.length,
+    entries: trimmed.map((e) => ({
+      id: e.id,
+      type: e.type,
+      summary: e.summary,
+      importance: e.importance,
+      tags: e.tags,
+      relatedFiles: e.relatedFiles,
+      accessCount: e.accessCount,
+      createdAt: e.createdAt,
+      updatedAt: e.updatedAt,
+      supersededBy: e.supersededBy
+    })),
+    summary: trimmed.length > 0 ? `Timeline: ${trimmed.length} memories (${entries.length} total matching)` : "No memories found matching the criteria"
+  };
+  return {
+    content: [{ type: "text", text: JSON.stringify(payload, null, 2) }]
+  };
+}
+var getSessionContextTool = {
+  name: "get_session_context",
+  description: "Get captured context from a specific session, including session metadata, captured events, and any memories extracted from that session.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      sessionId: { type: "string", description: "Session ID to look up (omit or 'latest' for most recent)" }
+    }
+  }
+};
+async function handleGetSessionContext(projectDir, args) {
+  const sessionId = typeof args.sessionId === "string" && args.sessionId !== "latest" ? args.sessionId : void 0;
+  const sessions = listCapturedSessions(projectDir);
+  if (sessions.length === 0) {
+    return {
+      content: [{ type: "text", text: JSON.stringify({
+        error: "No captured sessions found",
+        summary: "No sessions have been captured yet. Sessions are captured when memory is enabled in guards.yml."
+      }) }]
+    };
+  }
+  const target = sessionId ? sessions.find((s) => s.sessionId === sessionId) : sessions[sessions.length - 1];
+  if (!target) {
+    return {
+      content: [{ type: "text", text: JSON.stringify({
+        error: `Session not found: ${sessionId}`,
+        availableSessions: sessions.slice(-5).map((s) => ({
+          sessionId: s.sessionId,
+          capturedAt: s.capturedAt
+        })),
+        summary: `Session "${sessionId}" not found. Showing last 5 available sessions.`
+      }, null, 2) }]
+    };
+  }
+  const events = readCapturedEvents(projectDir, target.sessionId);
+  const allEntries = listEntries(projectDir);
+  const sessionMemories = allEntries.filter(
+    (e) => e.source.sessionId === target.sessionId
+  );
+  const payload = {
+    session: {
+      sessionId: target.sessionId,
+      projectDir: target.projectDir,
+      startedAt: target.startedAt,
+      endedAt: target.endedAt,
+      branch: target.branch,
+      sessionName: target.sessionName,
+      filesRead: target.filesRead,
+      filesWritten: target.filesWritten,
+      commandsRun: target.commandsRun,
+      transcriptCaptured: target.transcriptCaptured,
+      capturedAt: target.capturedAt
+    },
+    eventCount: events.length,
+    events: events.slice(0, 50).map((e) => ({
+      ts: e.ts,
+      event: e.event,
+      hookEvent: e.hookEvent,
+      toolName: e.toolName,
+      filePath: e.filePath,
+      command: e.command
+    })),
+    memoriesExtracted: sessionMemories.length,
+    memories: sessionMemories.map((m) => ({
+      id: m.id,
+      type: m.type,
+      summary: m.summary,
+      importance: m.importance,
+      tags: m.tags
+    })),
+    summary: `Session ${target.sessionId}: ${events.length} events, ${sessionMemories.length} memories extracted, ${target.filesRead} files read, ${target.filesWritten} files written`
+  };
+  return {
+    content: [{ type: "text", text: JSON.stringify(payload, null, 2) }]
+  };
+}
+var forgetTool = {
+  name: "forget",
+  description: "Remove or supersede a memory. By default, marks the memory as superseded (soft delete). Use hard=true to permanently delete it.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      memoryId: { type: "string", description: "The memory ID to forget" },
+      hard: { type: "boolean", description: "Permanently delete instead of marking superseded (default false)" },
+      supersededBy: { type: "string", description: "ID of the memory that replaces this one (optional)" }
+    },
+    required: ["memoryId"]
+  }
+};
+async function handleForget(projectDir, args) {
+  const memoryId = args.memoryId;
+  const hard = typeof args.hard === "boolean" ? args.hard : false;
+  const supersededBy = typeof args.supersededBy === "string" ? args.supersededBy : void 0;
+  const existing = loadEntry(projectDir, memoryId);
+  if (!existing) {
+    return {
+      content: [{ type: "text", text: JSON.stringify({
+        error: `Memory not found: ${memoryId}`,
+        summary: `No memory with ID "${memoryId}" exists`
+      }) }]
+    };
+  }
+  if (hard) {
+    const removed = removeEntry(projectDir, memoryId);
+    const payload2 = {
+      memoryId,
+      action: "deleted",
+      success: removed,
+      summary: removed ? `Memory ${memoryId} permanently deleted` : `Failed to delete memory ${memoryId}`
+    };
+    return {
+      content: [{ type: "text", text: JSON.stringify(payload2, null, 2) }]
+    };
+  }
+  const updated = updateEntry(projectDir, memoryId, {
+    supersededBy: supersededBy ?? "forgotten",
+    updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+  });
+  const payload = {
+    memoryId,
+    action: "superseded",
+    supersededBy: supersededBy ?? "forgotten",
+    success: updated !== null,
+    summary: updated ? `Memory ${memoryId} marked as superseded` : `Failed to update memory ${memoryId}`
+  };
+  return {
+    content: [{ type: "text", text: JSON.stringify(payload, null, 2) }]
+  };
+}
+var memoryStatsTool = {
+  name: "memory_stats",
+  description: "Get memory system statistics: total memories, counts by type and importance, total accesses, sessions captured, index size, and initialization status.",
+  inputSchema: {
+    type: "object",
+    properties: {}
+  }
+};
+async function handleMemoryStats(projectDir, _args) {
+  const stats = await getMemoryStats(projectDir);
+  const payload = {
+    ...stats,
+    summary: stats.initialized ? `Memory system: ${stats.totalMemories} memories, ${stats.sessionsCaptured} sessions captured, ${stats.sessionsClassified} classified, ${(stats.indexSizeBytes / 1024).toFixed(1)} KB index` : "Memory system not initialized. Enable memory in guards.yml and run a session to start capturing."
+  };
+  return {
+    content: [{ type: "text", text: JSON.stringify(payload, null, 2) }]
+  };
+}
+var ALL_TOOLS = [
+  searchMemoryTool,
+  saveMemoryTool,
+  getTimelineTool,
+  getSessionContextTool,
+  forgetTool,
+  memoryStatsTool
+];
+var HANDLERS = {
+  search_memory: handleSearchMemory,
+  save_memory: handleSaveMemory,
+  get_timeline: handleGetTimeline,
+  get_session_context: handleGetSessionContext,
+  forget: handleForget,
+  memory_stats: handleMemoryStats
+};
+function createMemoryMcpServer(options) {
+  const server = new Server(
+    { name: "memory", version: "0.1.0" },
+    { capabilities: { tools: {} } }
+  );
+  server.setRequestHandler(ListToolsRequestSchema, async () => ({
+    tools: ALL_TOOLS
+  }));
+  server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    const { name, arguments: args } = request.params;
+    const handler = HANDLERS[name];
+    if (!handler) {
+      return {
+        content: [{ type: "text", text: JSON.stringify({ error: `Unknown tool: ${name}` }) }],
+        isError: true
+      };
+    }
+    try {
+      return await handler(options.projectDir, args ?? {});
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      return {
+        content: [{ type: "text", text: JSON.stringify({ error: message }) }],
+        isError: true
+      };
+    }
+  });
+  return server;
+}
+async function startMemoryMcpServer(options) {
+  const server = createMemoryMcpServer(options);
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+}
+export {
+  createMemoryMcpServer,
+  startMemoryMcpServer
+};