kiro-memory 1.0.0

package/plugin/dist/servers/mcp-server.js

@@ -0,0 +1,266 @@
+#!/usr/bin/env node
+
+// src/servers/mcp-server.ts
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import {
+  CallToolRequestSchema,
+  ListToolsRequestSchema
+} from "@modelcontextprotocol/sdk/types.js";
+console.log = (...args) => console.error("[contextkit-mcp]", ...args);
+var WORKER_HOST = process.env.CONTEXTKIT_WORKER_HOST || "127.0.0.1";
+var WORKER_PORT = process.env.CONTEXTKIT_WORKER_PORT || "3001";
+var WORKER_BASE = `http://${WORKER_HOST}:${WORKER_PORT}`;
+async function callWorkerGET(endpoint, params = {}) {
+  const url = new URL(endpoint, WORKER_BASE);
+  Object.entries(params).forEach(([k, v]) => {
+    if (v !== void 0 && v !== null && v !== "") url.searchParams.set(k, v);
+  });
+  const resp = await fetch(url.toString(), { signal: AbortSignal.timeout(1e4) });
+  if (!resp.ok) throw new Error(`Worker ${resp.status}: ${await resp.text()}`);
+  return resp.json();
+}
+async function callWorkerPOST(endpoint, body) {
+  const url = new URL(endpoint, WORKER_BASE);
+  const resp = await fetch(url.toString(), {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify(body),
+    signal: AbortSignal.timeout(1e4)
+  });
+  if (!resp.ok) throw new Error(`Worker ${resp.status}: ${await resp.text()}`);
+  return resp.json();
+}
+var TOOLS = [
+  {
+    name: "search",
+    description: "Cerca nella memoria di ContextKit. Restituisce osservazioni e sommari che corrispondono alla query. Usa questo tool per trovare contesto da sessioni precedenti.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        query: { type: "string", description: "Testo da cercare nelle osservazioni e sommari" },
+        project: { type: "string", description: "Filtra per nome progetto (opzionale)" },
+        type: { type: "string", description: "Filtra per tipo osservazione: file-write, command, research, tool-use (opzionale)" },
+        limit: { type: "number", description: "Numero massimo risultati (default: 20)" }
+      },
+      required: ["query"]
+    }
+  },
+  {
+    name: "timeline",
+    description: "Mostra il contesto cronologico attorno a un'osservazione specifica. Utile per capire cosa \xE8 successo prima e dopo un evento.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        anchor: { type: "number", description: "ID dell'osservazione come punto di riferimento" },
+        depth_before: { type: "number", description: "Numero di osservazioni prima (default: 5)" },
+        depth_after: { type: "number", description: "Numero di osservazioni dopo (default: 5)" }
+      },
+      required: ["anchor"]
+    }
+  },
+  {
+    name: "get_observations",
+    description: 'Recupera i dettagli completi di osservazioni specifiche per ID. Usa dopo "search" per ottenere il contenuto completo.',
+    inputSchema: {
+      type: "object",
+      properties: {
+        ids: {
+          type: "array",
+          items: { type: "number" },
+          description: "Array di ID osservazioni da recuperare"
+        }
+      },
+      required: ["ids"]
+    }
+  },
+  {
+    name: "get_context",
+    description: "Recupera il contesto recente per un progetto: osservazioni, sommari e prompt recenti.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        project: { type: "string", description: "Nome del progetto" }
+      },
+      required: ["project"]
+    }
+  }
+];
+var handlers = {
+  async search(args) {
+    const result = await callWorkerGET("/api/search", {
+      q: args.query,
+      project: args.project || "",
+      type: args.type || "",
+      limit: String(args.limit || 20)
+    });
+    const obs = result.observations || [];
+    const sums = result.summaries || [];
+    if (obs.length === 0 && sums.length === 0) {
+      return "Nessun risultato trovato per la query.";
+    }
+    let output = `## Risultati ricerca: "${args.query}"
+
+`;
+    if (obs.length > 0) {
+      output += `### Osservazioni (${obs.length})
+
+`;
+      output += "| ID | Tipo | Titolo | Data |\n|---|---|---|---|\n";
+      obs.forEach((o) => {
+        output += `| ${o.id} | ${o.type} | ${o.title} | ${o.created_at?.split("T")[0] || ""} |
+`;
+      });
+      output += "\n";
+    }
+    if (sums.length > 0) {
+      output += `### Sommari (${sums.length})
+
+`;
+      sums.forEach((s) => {
+        if (s.learned) output += `- **Appreso**: ${s.learned}
+`;
+        if (s.completed) output += `- **Completato**: ${s.completed}
+`;
+      });
+    }
+    return output;
+  },
+  async timeline(args) {
+    const result = await callWorkerGET("/api/timeline", {
+      anchor: String(args.anchor),
+      depth_before: String(args.depth_before || 5),
+      depth_after: String(args.depth_after || 5)
+    });
+    const entries = result.timeline || result || [];
+    if (!Array.isArray(entries) || entries.length === 0) {
+      return `Nessun contesto trovato attorno all'osservazione ${args.anchor}.`;
+    }
+    let output = `## Timeline attorno all'osservazione #${args.anchor}
+
+`;
+    entries.forEach((e) => {
+      const marker = e.id === args.anchor ? "\u2192 " : "  ";
+      output += `${marker}**#${e.id}** [${e.type}] ${e.title} (${e.created_at?.split("T")[0] || ""})
+`;
+      if (e.content) output += `  ${e.content.substring(0, 200)}
+`;
+      output += "\n";
+    });
+    return output;
+  },
+  async get_observations(args) {
+    const result = await callWorkerPOST("/api/observations/batch", { ids: args.ids });
+    const obs = result.observations || result || [];
+    if (!Array.isArray(obs) || obs.length === 0) {
+      return "Nessuna osservazione trovata per gli ID specificati.";
+    }
+    let output = `## Dettagli Osservazioni
+
+`;
+    obs.forEach((o) => {
+      output += `### #${o.id}: ${o.title}
+`;
+      output += `- **Tipo**: ${o.type}
+`;
+      output += `- **Progetto**: ${o.project}
+`;
+      output += `- **Data**: ${o.created_at}
+`;
+      if (o.text) output += `- **Contenuto**: ${o.text}
+`;
+      if (o.narrative) output += `- **Narrativa**: ${o.narrative}
+`;
+      if (o.concepts) output += `- **Concetti**: ${o.concepts}
+`;
+      if (o.files_read) output += `- **File letti**: ${o.files_read}
+`;
+      if (o.files_modified) output += `- **File modificati**: ${o.files_modified}
+`;
+      output += "\n";
+    });
+    return output;
+  },
+  async get_context(args) {
+    const result = await callWorkerGET(`/api/context/${encodeURIComponent(args.project)}`);
+    const obs = result.observations || [];
+    const sums = result.summaries || [];
+    let output = `## Contesto: ${args.project}
+
+`;
+    if (sums.length > 0) {
+      output += `### Sommari Recenti
+
+`;
+      sums.forEach((s) => {
+        if (s.request) output += `**Richiesta**: ${s.request}
+`;
+        if (s.learned) output += `- Appreso: ${s.learned}
+`;
+        if (s.completed) output += `- Completato: ${s.completed}
+`;
+        if (s.next_steps) output += `- Prossimi passi: ${s.next_steps}
+
+`;
+      });
+    }
+    if (obs.length > 0) {
+      output += `### Osservazioni Recenti (${obs.length})
+
+`;
+      obs.slice(0, 10).forEach((o) => {
+        output += `- **${o.title}** [${o.type}]: ${(o.text || "").substring(0, 100)}
+`;
+      });
+    }
+    return output;
+  }
+};
+async function main() {
+  const server = new Server(
+    { name: "contextkit", version: "1.0.0" },
+    { capabilities: { tools: {} } }
+  );
+  server.setRequestHandler(ListToolsRequestSchema, async () => ({
+    tools: TOOLS
+  }));
+  server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    const { name, arguments: args } = request.params;
+    const handler = handlers[name];
+    if (!handler) {
+      return {
+        content: [{ type: "text", text: `Tool sconosciuto: ${name}` }],
+        isError: true
+      };
+    }
+    try {
+      const result = await handler(args || {});
+      return {
+        content: [{ type: "text", text: result }]
+      };
+    } catch (error) {
+      const msg = error?.message || String(error);
+      if (msg.includes("ECONNREFUSED") || msg.includes("fetch failed")) {
+        return {
+          content: [{
+            type: "text",
+            text: `Worker ContextKit non raggiungibile su ${WORKER_BASE}.
+Avvia il worker con: cd <contextkit-dir> && npm run worker:start`
+          }],
+          isError: true
+        };
+      }
+      return {
+        content: [{ type: "text", text: `Errore: ${msg}` }],
+        isError: true
+      };
+    }
+  });
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+  console.log("ContextKit MCP server avviato su stdio");
+}
+main().catch((err) => {
+  console.error("Errore avvio MCP server:", err);
+  process.exit(1);
+});

package/plugin/dist/services/search/ChromaManager.js

@@ -0,0 +1,357 @@
+// src/services/search/ChromaManager.ts
+import { ChromaClient } from "chromadb";
+import { join as join2 } from "path";
+import { homedir as homedir2 } from "os";
+import { existsSync as existsSync2, mkdirSync as mkdirSync2 } from "fs";
+
+// src/utils/logger.ts
+import { appendFileSync, existsSync, mkdirSync, readFileSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+var LogLevel = /* @__PURE__ */ ((LogLevel2) => {
+  LogLevel2[LogLevel2["DEBUG"] = 0] = "DEBUG";
+  LogLevel2[LogLevel2["INFO"] = 1] = "INFO";
+  LogLevel2[LogLevel2["WARN"] = 2] = "WARN";
+  LogLevel2[LogLevel2["ERROR"] = 3] = "ERROR";
+  LogLevel2[LogLevel2["SILENT"] = 4] = "SILENT";
+  return LogLevel2;
+})(LogLevel || {});
+var DEFAULT_DATA_DIR = join(homedir(), ".contextkit");
+var Logger = class {
+  level = null;
+  useColor;
+  logFilePath = null;
+  logFileInitialized = false;
+  constructor() {
+    this.useColor = process.stdout.isTTY ?? false;
+  }
+  /**
+   * Initialize log file path and ensure directory exists (lazy initialization)
+   */
+  ensureLogFileInitialized() {
+    if (this.logFileInitialized) return;
+    this.logFileInitialized = true;
+    try {
+      const logsDir = join(DEFAULT_DATA_DIR, "logs");
+      if (!existsSync(logsDir)) {
+        mkdirSync(logsDir, { recursive: true });
+      }
+      const date = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+      this.logFilePath = join(logsDir, `contextkit-${date}.log`);
+    } catch (error) {
+      console.error("[LOGGER] Failed to initialize log file:", error);
+      this.logFilePath = null;
+    }
+  }
+  /**
+   * Lazy-load log level from settings file
+   */
+  getLevel() {
+    if (this.level === null) {
+      try {
+        const settingsPath = join(DEFAULT_DATA_DIR, "settings.json");
+        if (existsSync(settingsPath)) {
+          const settingsData = readFileSync(settingsPath, "utf-8");
+          const settings = JSON.parse(settingsData);
+          const envLevel = (settings.CONTEXTKIT_LOG_LEVEL || "INFO").toUpperCase();
+          this.level = LogLevel[envLevel] ?? 1 /* INFO */;
+        } else {
+          this.level = 1 /* INFO */;
+        }
+      } catch (error) {
+        this.level = 1 /* INFO */;
+      }
+    }
+    return this.level;
+  }
+  /**
+   * Create correlation ID for tracking an observation through the pipeline
+   */
+  correlationId(sessionId, observationNum) {
+    return `obs-${sessionId}-${observationNum}`;
+  }
+  /**
+   * Create session correlation ID
+   */
+  sessionId(sessionId) {
+    return `session-${sessionId}`;
+  }
+  /**
+   * Format data for logging - create compact summaries instead of full dumps
+   */
+  formatData(data) {
+    if (data === null || data === void 0) return "";
+    if (typeof data === "string") return data;
+    if (typeof data === "number") return data.toString();
+    if (typeof data === "boolean") return data.toString();
+    if (typeof data === "object") {
+      if (data instanceof Error) {
+        return this.getLevel() === 0 /* DEBUG */ ? `${data.message}
+${data.stack}` : data.message;
+      }
+      if (Array.isArray(data)) {
+        return `[${data.length} items]`;
+      }
+      const keys = Object.keys(data);
+      if (keys.length === 0) return "{}";
+      if (keys.length <= 3) {
+        return JSON.stringify(data);
+      }
+      return `{${keys.length} keys: ${keys.slice(0, 3).join(", ")}...}`;
+    }
+    return String(data);
+  }
+  /**
+   * Format timestamp in local timezone (YYYY-MM-DD HH:MM:SS.mmm)
+   */
+  formatTimestamp(date) {
+    const year = date.getFullYear();
+    const month = String(date.getMonth() + 1).padStart(2, "0");
+    const day = String(date.getDate()).padStart(2, "0");
+    const hours = String(date.getHours()).padStart(2, "0");
+    const minutes = String(date.getMinutes()).padStart(2, "0");
+    const seconds = String(date.getSeconds()).padStart(2, "0");
+    const ms = String(date.getMilliseconds()).padStart(3, "0");
+    return `${year}-${month}-${day} ${hours}:${minutes}:${seconds}.${ms}`;
+  }
+  /**
+   * Core logging method
+   */
+  log(level, component, message, context, data) {
+    if (level < this.getLevel()) return;
+    this.ensureLogFileInitialized();
+    const timestamp = this.formatTimestamp(/* @__PURE__ */ new Date());
+    const levelStr = LogLevel[level].padEnd(5);
+    const componentStr = component.padEnd(6);
+    let correlationStr = "";
+    if (context?.correlationId) {
+      correlationStr = `[${context.correlationId}] `;
+    } else if (context?.sessionId) {
+      correlationStr = `[session-${context.sessionId}] `;
+    }
+    let dataStr = "";
+    if (data !== void 0 && data !== null) {
+      if (data instanceof Error) {
+        dataStr = this.getLevel() === 0 /* DEBUG */ ? `
+${data.message}
+${data.stack}` : ` ${data.message}`;
+      } else if (this.getLevel() === 0 /* DEBUG */ && typeof data === "object") {
+        dataStr = "\n" + JSON.stringify(data, null, 2);
+      } else {
+        dataStr = " " + this.formatData(data);
+      }
+    }
+    let contextStr = "";
+    if (context) {
+      const { sessionId, memorySessionId, correlationId, ...rest } = context;
+      if (Object.keys(rest).length > 0) {
+        const pairs = Object.entries(rest).map(([k, v]) => `${k}=${v}`);
+        contextStr = ` {${pairs.join(", ")}}`;
+      }
+    }
+    const logLine = `[${timestamp}] [${levelStr}] [${componentStr}] ${correlationStr}${message}${contextStr}${dataStr}`;
+    if (this.logFilePath) {
+      try {
+        appendFileSync(this.logFilePath, logLine + "\n", "utf8");
+      } catch (error) {
+        process.stderr.write(`[LOGGER] Failed to write to log file: ${error}
+`);
+      }
+    } else {
+      process.stderr.write(logLine + "\n");
+    }
+  }
+  // Public logging methods
+  debug(component, message, context, data) {
+    this.log(0 /* DEBUG */, component, message, context, data);
+  }
+  info(component, message, context, data) {
+    this.log(1 /* INFO */, component, message, context, data);
+  }
+  warn(component, message, context, data) {
+    this.log(2 /* WARN */, component, message, context, data);
+  }
+  error(component, message, context, data) {
+    this.log(3 /* ERROR */, component, message, context, data);
+  }
+  /**
+   * Log data flow: input → processing
+   */
+  dataIn(component, message, context, data) {
+    this.info(component, `\u2192 ${message}`, context, data);
+  }
+  /**
+   * Log data flow: processing → output
+   */
+  dataOut(component, message, context, data) {
+    this.info(component, `\u2190 ${message}`, context, data);
+  }
+  /**
+   * Log successful completion
+   */
+  success(component, message, context, data) {
+    this.info(component, `\u2713 ${message}`, context, data);
+  }
+  /**
+   * Log failure
+   */
+  failure(component, message, context, data) {
+    this.error(component, `\u2717 ${message}`, context, data);
+  }
+  /**
+   * Log timing information
+   */
+  timing(component, message, durationMs, context) {
+    this.info(component, `\u23F1 ${message}`, context, { duration: `${durationMs}ms` });
+  }
+  /**
+   * Happy Path Error - logs when the expected "happy path" fails but we have a fallback
+   */
+  happyPathError(component, message, context, data, fallback = "") {
+    const stack = new Error().stack || "";
+    const stackLines = stack.split("\n");
+    const callerLine = stackLines[2] || "";
+    const callerMatch = callerLine.match(/at\s+(?:.*\s+)?\(?([^:]+):(\d+):(\d+)\)?/);
+    const location = callerMatch ? `${callerMatch[1].split("/").pop()}:${callerMatch[2]}` : "unknown";
+    const enhancedContext = {
+      ...context,
+      location
+    };
+    this.warn(component, `[HAPPY-PATH] ${message}`, enhancedContext, data);
+    return fallback;
+  }
+};
+var logger = new Logger();
+
+// src/services/search/ChromaManager.ts
+var VECTOR_DB_DIR = join2(homedir2(), ".contextkit", "vector-db");
+var ChromaManager = class {
+  client;
+  collection = null;
+  isAvailable = false;
+  constructor() {
+    if (!existsSync2(VECTOR_DB_DIR)) {
+      mkdirSync2(VECTOR_DB_DIR, { recursive: true });
+    }
+    this.client = new ChromaClient({
+      path: process.env.CHROMADB_URL || "http://localhost:8000"
+    });
+  }
+  /**
+   * Initialize ChromaDB connection and collection
+   */
+  async initialize() {
+    try {
+      await this.client.heartbeat();
+      this.collection = await this.client.getOrCreateCollection({
+        name: "contextkit-observations",
+        metadata: { description: "ContextKit observation embeddings" }
+      });
+      this.isAvailable = true;
+      logger.info("CHROMA", "ChromaDB initialized successfully");
+      return true;
+    } catch (error) {
+      logger.warn("CHROMA", "ChromaDB not available, falling back to SQLite search", {}, error);
+      this.isAvailable = false;
+      return false;
+    }
+  }
+  /**
+   * Add observation embedding to ChromaDB
+   */
+  async addObservation(id, content, metadata) {
+    if (!this.isAvailable || !this.collection) {
+      logger.debug("CHROMA", "ChromaDB not available, skipping embedding");
+      return;
+    }
+    try {
+      await this.collection.add({
+        ids: [id],
+        documents: [content],
+        metadatas: [metadata]
+      });
+      logger.debug("CHROMA", `Added observation ${id} to vector DB`);
+    } catch (error) {
+      logger.error("CHROMA", `Failed to add observation ${id}`, {}, error);
+    }
+  }
+  /**
+   * Search observations by semantic similarity
+   */
+  async search(query, options = {}) {
+    if (!this.isAvailable || !this.collection) {
+      logger.debug("CHROMA", "ChromaDB not available, returning empty results");
+      return [];
+    }
+    try {
+      const where = options.project ? { project: options.project } : void 0;
+      const results = await this.collection.query({
+        queryTexts: [query],
+        nResults: options.limit || 10,
+        where
+      });
+      const hits = [];
+      if (results.ids && results.ids[0]) {
+        for (let i = 0; i < results.ids[0].length; i++) {
+          hits.push({
+            id: results.ids[0][i],
+            content: results.documents?.[0]?.[i] || "",
+            metadata: results.metadatas?.[0]?.[i] || {},
+            distance: results.distances?.[0]?.[i] || 0
+          });
+        }
+      }
+      logger.debug("CHROMA", `Search returned ${hits.length} results`);
+      return hits;
+    } catch (error) {
+      logger.error("CHROMA", "Search failed", {}, error);
+      return [];
+    }
+  }
+  /**
+   * Delete observation from ChromaDB
+   */
+  async deleteObservation(id) {
+    if (!this.isAvailable || !this.collection) {
+      return;
+    }
+    try {
+      await this.collection.delete({ ids: [id] });
+      logger.debug("CHROMA", `Deleted observation ${id}`);
+    } catch (error) {
+      logger.error("CHROMA", `Failed to delete observation ${id}`, {}, error);
+    }
+  }
+  /**
+   * Check if ChromaDB is available
+   */
+  isChromaAvailable() {
+    return this.isAvailable;
+  }
+  /**
+   * Get collection stats
+   */
+  async getStats() {
+    if (!this.isAvailable || !this.collection) {
+      return { count: 0 };
+    }
+    try {
+      const count = await this.collection.count();
+      return { count };
+    } catch (error) {
+      logger.error("CHROMA", "Failed to get stats", {}, error);
+      return { count: 0 };
+    }
+  }
+};
+var chromaManager = null;
+function getChromaManager() {
+  if (!chromaManager) {
+    chromaManager = new ChromaManager();
+  }
+  return chromaManager;
+}
+export {
+  ChromaManager,
+  getChromaManager
+};