@plumpslabs/kuma 2.3.20 → 2.3.23

package/dist/kumaProgressiveContext-MWEDRXOH.js

@@ -1,231 +0,0 @@
-import {
-  getActiveGotchas,
-  readLayer
-} from "./chunk-FKRSI5U5.js";
-import "./chunk-LVKOGXLC.js";
-import {
-  getDb
-} from "./chunk-3BRBJZ7P.js";
-import {
-  getProjectRoot
-} from "./chunk-E2KFPEBT.js";
-
-// src/engine/kumaProgressiveContext.ts
-import fs from "fs";
-import path from "path";
-async function getProjectMeta() {
-  const root = getProjectRoot();
-  const name = root.split("/").pop() || "unknown";
-  const stack = [];
-  if (fs.existsSync(path.join(root, "package.json"))) {
-    try {
-      const pkg = JSON.parse(fs.readFileSync(path.join(root, "package.json"), "utf-8"));
-      if (pkg.dependencies?.next) stack.push("Next.js");
-      else if (pkg.dependencies?.react) stack.push("React");
-      if (pkg.devDependencies?.typescript) stack.push("TypeScript");
-      if (fs.existsSync(path.join(root, "pnpm-lock.yaml"))) stack.push("pnpm");
-      else if (fs.existsSync(path.join(root, "yarn.lock"))) stack.push("yarn");
-    } catch {
-    }
-  }
-  if (fs.existsSync(path.join(root, "go.mod"))) stack.push("Go");
-  if (fs.existsSync(path.join(root, "Cargo.toml"))) stack.push("Rust");
-  if (fs.existsSync(path.join(root, "pyproject.toml"))) stack.push("Python");
-  let nodeCount = 0;
-  let edgeCount = 0;
-  try {
-    const db = await getDb();
-    const nodeRes = db.exec("SELECT COUNT(*) as c FROM nodes");
-    nodeCount = nodeRes[0]?.values[0]?.[0] ?? 0;
-    const edgeRes = db.exec("SELECT COUNT(*) as c FROM edges");
-    edgeCount = edgeRes[0]?.values[0]?.[0] ?? 0;
-  } catch {
-  }
-  const kumaDir = path.join(root, ".kuma");
-  const layerStatus = {
-    domainRules: fs.existsSync(path.join(kumaDir, "DOMAIN_RULES.md")),
-    archFlow: fs.existsSync(path.join(kumaDir, "ARCHITECTURE_FLOW.md")),
-    gotchas: getActiveGotchas().length
-  };
-  let hasDecisions = false;
-  let hasTodos = false;
-  try {
-    const db = await getDb();
-    const decRes = db.exec("SELECT COUNT(*) as c FROM decision_log");
-    hasDecisions = (decRes[0]?.values[0]?.[0] ?? 0) > 0;
-    const todoRes = db.exec("SELECT COUNT(*) as c FROM todos WHERE status != 'done'");
-    hasTodos = (todoRes[0]?.values[0]?.[0] ?? 0) > 0;
-  } catch {
-  }
-  return { name, stack, entryPoints: [], nodeCount, edgeCount, layerStatus, hasDecisions, hasTodos };
-}
-function formatProjectMeta(meta) {
-  const parts = [
-    `\u{1F4C1} ${meta.name}`,
-    meta.stack.length > 0 ? `\u26A1 ${meta.stack.join("/")}` : "",
-    `\u{1F4CA} ${meta.nodeCount}n/${meta.edgeCount}e`,
-    meta.layerStatus.domainRules ? "\u{1F4CB}R" : "",
-    meta.layerStatus.archFlow ? "\u{1F3D7}\uFE0FA" : "",
-    meta.layerStatus.gotchas > 0 ? `\u26A0\uFE0F${meta.layerStatus.gotchas}g` : "",
-    meta.hasDecisions ? "\u{1F4DD}D" : "",
-    meta.hasTodos ? "\u{1F4CC}T" : ""
-  ].filter(Boolean);
-  return parts.join(" | ");
-}
-async function loadSection(section, scope) {
-  switch (section) {
-    case "domain_rules": {
-      try {
-        const content = readLayer("domain_rules");
-        const lines = content.split("\n").filter((l) => l.trim() && !l.startsWith("<!--"));
-        return `\u{1F4CB} **Domain Rules**
-${lines.slice(0, 20).join("\n")}`;
-      } catch {
-        return "\u{1F4CB} **Domain Rules**: not configured";
-      }
-    }
-    case "architecture": {
-      try {
-        const content = readLayer("arch_flow");
-        const relevant = scope ? content.split("\n").filter((l) => l.toLowerCase().includes(scope.toLowerCase())).slice(0, 15) : content.split("\n").filter((l) => l.trim() && !l.startsWith("<!--")).slice(0, 20);
-        return `\u{1F3D7}\uFE0F **Architecture${scope ? `: ${scope}` : ""}**
-${relevant.join("\n")}`;
-      } catch {
-        return "\u{1F3D7}\uFE0F **Architecture**: not documented";
-      }
-    }
-    case "gotchas": {
-      const gotchas = getActiveGotchas();
-      if (gotchas.length === 0) return "\u26A0\uFE0F **Gotchas**: none recorded";
-      const filtered = scope ? gotchas.filter((g) => g.filePath.toLowerCase().includes(scope.toLowerCase())) : gotchas;
-      const lines = filtered.slice(0, 5).map((g) => {
-        const icon = g.severity === "critical" ? "\u{1F534}" : g.severity === "high" ? "\u{1F7E0}" : "\u{1F7E1}";
-        return `${icon} ${g.filePath}: ${g.description.substring(0, 80)}`;
-      });
-      return `\u26A0\uFE0F **Gotchas** (${filtered.length} active)
-${lines.join("\n")}`;
-    }
-    case "decisions": {
-      try {
-        const db = await getDb();
-        const stmt = db.prepare(
-          `SELECT title, status, created_at FROM decision_log ORDER BY created_at DESC LIMIT 10`
-        );
-        const results = [];
-        while (stmt.step()) results.push(stmt.getAsObject());
-        stmt.free();
-        if (results.length === 0) return "\u{1F4DD} **Decisions**: none recorded";
-        const lines = results.map(
-          (d) => `  ${d.status === "active" ? "\u2705" : "\u{1F4DD}"} ${d.title} (${d.status})`
-        );
-        return `\u{1F4DD} **Decisions** (${results.length})
-${lines.join("\n")}`;
-      } catch {
-        return "\u{1F4DD} **Decisions**: unavailable";
-      }
-    }
-    case "graph": {
-      try {
-        const db = await getDb();
-        const nodeRes = db.exec("SELECT type, COUNT(*) as cnt FROM nodes GROUP BY type ORDER BY cnt DESC LIMIT 8");
-        if (!nodeRes[0]?.values) return "\u{1F4CA} **Graph**: empty";
-        const lines = nodeRes[0].values.map((r) => `  ${r[0]}: ${r[1]}`);
-        return `\u{1F4CA} **Knowledge Graph**
-${lines.join("\n")}`;
-      } catch {
-        return "\u{1F4CA} **Graph**: unavailable";
-      }
-    }
-    case "changes": {
-      try {
-        const db = await getDb();
-        const stmt = db.prepare("SELECT file_path, change_type FROM change_log ORDER BY id DESC LIMIT 8");
-        const results = [];
-        while (stmt.step()) results.push(stmt.getAsObject());
-        stmt.free();
-        if (results.length === 0) return "\u{1F4DD} **Changes**: none in this session";
-        const lines = results.map(
-          (r) => `  ${r.change_type === "modified" ? "\u{1F4DD}" : r.change_type === "created" ? "\u2728" : "\u274C"} ${r.file_path}`
-        );
-        return `\u{1F4DD} **Recent Changes** (${results.length})
-${lines.join("\n")}`;
-      } catch {
-        return "\u{1F4DD} **Changes**: unavailable";
-      }
-    }
-    case "health": {
-      try {
-        const { computeSafetyScore } = await import("./safetyScore-TMMRD2MV.js");
-        const score = await computeSafetyScore();
-        return `\u{1F3E5} **Health**: ${score.score}/100 (${score.risk})`;
-      } catch {
-        return "\u{1F3E5} **Health**: unavailable";
-      }
-    }
-    default:
-      return `Unknown section: ${section}`;
-  }
-}
-function getSkillBoundary(skillArea) {
-  const area = skillArea.toLowerCase();
-  if (area.includes("auth") || area.includes("login") || area.includes("security")) {
-    return {
-      name: "auth",
-      relatedSections: ["domain_rules", "architecture", "gotchas", "decisions"],
-      relatedPaths: ["src/auth", "src/middleware", "src/guards"],
-      description: "Authentication & authorization context"
-    };
-  }
-  if (area.includes("test") || area.includes("spec")) {
-    return {
-      name: "testing",
-      relatedSections: ["gotchas", "health"],
-      relatedPaths: ["__tests__", "*.test.*", "*.spec.*"],
-      description: "Testing & verification context"
-    };
-  }
-  if (area.includes("db") || area.includes("database") || area.includes("schema")) {
-    return {
-      name: "database",
-      relatedSections: ["architecture", "gotchas", "decisions"],
-      relatedPaths: ["prisma", "src/db", "schema", "migrations"],
-      description: "Database & schema context"
-    };
-  }
-  if (area.includes("api") || area.includes("route") || area.includes("endpoint")) {
-    return {
-      name: "api",
-      relatedSections: ["architecture", "gotchas", "decisions", "changes"],
-      relatedPaths: ["src/api", "src/routes", "src/controllers"],
-      description: "API & routing context"
-    };
-  }
-  return {
-    name: "general",
-    relatedSections: ["domain_rules", "gotchas"],
-    relatedPaths: [],
-    description: "General project context"
-  };
-}
-async function getProgressiveContext(skillArea) {
-  const meta = await getProjectMeta();
-  const boundary = getSkillBoundary(skillArea || "general");
-  const sections = await Promise.all(
-    boundary.relatedSections.map(async (section) => ({
-      name: section,
-      content: await loadSection(section, skillArea)
-    }))
-  );
-  return {
-    meta: formatProjectMeta(meta),
-    sections,
-    boundary
-  };
-}
-export {
-  formatProjectMeta,
-  getProgressiveContext,
-  getProjectMeta,
-  getSkillBoundary,
-  loadSection
-};

package/dist/kumaSearch-PV4QTKE7.js

@@ -1,321 +0,0 @@
-import {
-  getDb
-} from "./chunk-3BRBJZ7P.js";
-import {
-  getProjectRoot
-} from "./chunk-E2KFPEBT.js";
-
-// src/engine/kumaSearch.ts
-import fs from "fs";
-import path from "path";
-var SYNONYM_MAP = {
-  timeout: ["timeout", "duration", "expiry", "ttl", "deadline", "latency"],
-  duration: ["duration", "timeout", "length", "period", "interval"],
-  delay: ["delay", "wait", "latency", "defer", "throttle"],
-  latency: ["latency", "delay", "response time", "speed", "performance"],
-  error: ["error", "failure", "exception", "bug", "fault", "crash"],
-  crash: ["crash", "panic", "oom", "out of memory", "segfault"],
-  fail: ["fail", "error", "break", "regression", "broken"],
-  auth: ["auth", "authentication", "login", "oauth", "session", "token", "credential"],
-  login: ["login", "signin", "auth", "authenticate"],
-  token: ["token", "jwt", "session", "api key", "secret"],
-  permission: ["permission", "access", "role", "rbac", "authorization", "acl"],
-  database: ["database", "db", "storage", "persistence", "sql", "nosql"],
-  query: ["query", "search", "fetch", "select", "lookup"],
-  index: ["index", "key", "lookup", "search"],
-  cache: ["cache", "memcached", "redis", "buffer", "temporary storage"],
-  api: ["api", "endpoint", "route", "rest", "graphql", "service"],
-  route: ["route", "endpoint", "path", "handler"],
-  request: ["request", "http", "call", "fetch", "invocation"],
-  response: ["response", "reply", "result", "output"],
-  performance: ["performance", "speed", "latency", "throughput", "efficiency"],
-  memory: ["memory", "ram", "heap", "allocation", "leak"],
-  cpu: ["cpu", "processor", "compute", "thread", "worker"],
-  architecture: ["architecture", "design", "pattern", "structure", "system"],
-  service: ["service", "microservice", "module", "component", "layer"],
-  config: ["config", "configuration", "setting", "env", "environment"],
-  deploy: ["deploy", "release", "rollout", "publish", "ship"],
-  build: ["build", "compile", "bundle", "transpile", "package"],
-  test: ["test", "spec", "unit test", "integration", "e2e"],
-  lint: ["lint", "format", "style", "prettier", "eslint"],
-  redis: ["redis", "cache", "session store", "message queue"],
-  postgres: ["postgres", "postgresql", "psql", "relational db", "sql"],
-  docker: ["docker", "container", "image", "dockerfile", "compose"],
-  typescript: ["typescript", "ts", "type system", "compiler"],
-  prisma: ["prisma", "orm", "database client", "schema"],
-  create: ["create", "add", "new", "make", "generate"],
-  update: ["update", "modify", "change", "edit", "patch"],
-  delete: ["delete", "remove", "drop", "clear", "purge"]
-};
-function expandQueryTerms(query) {
-  const terms = query.toLowerCase().split(/[\s_-]+/).filter((t) => t.length > 2);
-  const expanded = /* @__PURE__ */ new Map();
-  for (const term of terms) {
-    const sources = /* @__PURE__ */ new Set();
-    sources.add(term);
-    if (SYNONYM_MAP[term]) {
-      for (const syn of SYNONYM_MAP[term]) {
-        sources.add(syn);
-      }
-    }
-    for (const [key, synonyms] of Object.entries(SYNONYM_MAP)) {
-      if (synonyms.includes(term)) {
-        sources.add(key);
-      }
-    }
-    expanded.set(term, sources);
-  }
-  return expanded;
-}
-var _vectorCache = null;
-var VECTOR_CACHE_TTL = 3e5;
-async function buildSearchVectors() {
-  if (_vectorCache && Date.now() - _vectorCache.builtAt < VECTOR_CACHE_TTL) {
-    return _vectorCache.vectors;
-  }
-  const vectors = [];
-  try {
-    const db = await getDb();
-    const stmt = db.prepare("SELECT id, name, metadata, file_path FROM nodes ORDER BY updated_at DESC LIMIT 500");
-    while (stmt.step()) {
-      const row = stmt.getAsObject();
-      const name = row.name || "";
-      const metaStr = row.metadata || "{}";
-      let metaText = "";
-      try {
-        const meta = JSON.parse(metaStr);
-        metaText = Object.values(meta).join(" ");
-      } catch {
-      }
-      const filePath = row.file_path || "";
-      const nodeText = `${name} ${metaText} ${filePath}`.toLowerCase();
-      const rawTerms = extractTerms(nodeText);
-      const termCounts = /* @__PURE__ */ new Map();
-      for (const t of rawTerms) {
-        termCounts.set(t, (termCounts.get(t) || 0) + 1);
-      }
-      vectors.push({
-        terms: termCounts,
-        source: name || row.id,
-        sourceType: "graph"
-      });
-    }
-    stmt.free();
-  } catch {
-  }
-  try {
-    const root = getProjectRoot();
-    const memDir = path.join(root, ".kuma", "memories");
-    if (fs.existsSync(memDir)) {
-      const files = fs.readdirSync(memDir).filter((f) => f.endsWith(".md")).slice(0, 10);
-      for (const file of files) {
-        try {
-          const content = fs.readFileSync(path.join(memDir, file), "utf-8");
-          const text = content.toLowerCase();
-          const rawTerms = extractTerms(text);
-          const termCounts = /* @__PURE__ */ new Map();
-          for (const t of rawTerms) {
-            termCounts.set(t, (termCounts.get(t) || 0) + 1);
-          }
-          vectors.push({
-            terms: termCounts,
-            source: file.replace(/\.md$/, ""),
-            sourceType: "memory"
-          });
-        } catch {
-        }
-      }
-    }
-  } catch {
-  }
-  try {
-    const db = await getDb();
-    const stmt = db.prepare("SELECT scope, record FROM research_cache ORDER BY updated_at DESC LIMIT 50");
-    while (stmt.step()) {
-      const row = stmt.getAsObject();
-      const scope = row.scope || "";
-      const record = row.record || "";
-      const text = `${scope} ${record}`.toLowerCase();
-      const rawTerms = extractTerms(text);
-      const termCounts = /* @__PURE__ */ new Map();
-      for (const t of rawTerms) {
-        termCounts.set(t, (termCounts.get(t) || 0) + 1);
-      }
-      vectors.push({
-        terms: termCounts,
-        source: scope,
-        sourceType: "research"
-      });
-    }
-    stmt.free();
-  } catch {
-  }
-  const docCount = vectors.length || 1;
-  const docFreq = /* @__PURE__ */ new Map();
-  for (const vec of vectors) {
-    const seen = /* @__PURE__ */ new Set();
-    for (const [term] of vec.terms) {
-      if (!seen.has(term)) {
-        docFreq.set(term, (docFreq.get(term) || 0) + 1);
-        seen.add(term);
-      }
-    }
-  }
-  for (const vec of vectors) {
-    const maxFreq = Math.max(1, ...Array.from(vec.terms.values()));
-    for (const [term, rawFreq] of vec.terms) {
-      const tf = 0.5 + 0.5 * rawFreq / maxFreq;
-      const docsWithTerm = docFreq.get(term) || 1;
-      const idf = Math.log(1 + (docCount - docsWithTerm + 0.5) / (docsWithTerm + 0.5));
-      vec.terms.set(term, tf * idf);
-    }
-  }
-  _vectorCache = { vectors, builtAt: Date.now() };
-  return vectors;
-}
-function extractTerms(text) {
-  return text.toLowerCase().split(/[\s,.;:!?()\[\]{}"'\/\\|@#$%^&*+=<>~`]+/).filter((t) => t.length > 2 && t.length < 50 && !/^\d+$/.test(t));
-}
-function cosineSimilarity(queryVec, docVec) {
-  let dotProduct = 0;
-  let queryMagnitude = 0;
-  let docMagnitude = 0;
-  for (const [term, qWeight] of queryVec) {
-    queryMagnitude += qWeight * qWeight;
-    const dWeight = docVec.get(term) || 0;
-    dotProduct += qWeight * dWeight;
-  }
-  for (const [, dWeight] of docVec) {
-    docMagnitude += dWeight * dWeight;
-  }
-  const mag = Math.sqrt(queryMagnitude) * Math.sqrt(docMagnitude);
-  if (mag === 0) return 0;
-  return dotProduct / mag;
-}
-async function hybridSearch(query, limit = 10) {
-  const results = [];
-  const expandedTerms = expandQueryTerms(query);
-  const allSearchTerms = /* @__PURE__ */ new Set();
-  for (const [, sources] of expandedTerms) {
-    for (const term of sources) {
-      allSearchTerms.add(term);
-    }
-  }
-  const searchTerms = Array.from(allSearchTerms);
-  const queryVector = /* @__PURE__ */ new Map();
-  for (const [originalTerm, sources] of expandedTerms) {
-    for (const term of sources) {
-      const weight = term === originalTerm ? 2 : 1;
-      queryVector.set(term, (queryVector.get(term) || 0) + weight);
-    }
-  }
-  try {
-    const db = await getDb();
-    const likeClauses = searchTerms.map(() => `name LIKE ?`).join(" OR ");
-    const sql = `SELECT id, name, type, file_path, metadata FROM nodes WHERE (${likeClauses}) LIMIT ${limit * 3}`;
-    const stmt = db.prepare(sql);
-    stmt.bind(searchTerms.map((t) => `%${t}%`));
-    const seen = /* @__PURE__ */ new Set();
-    while (stmt.step()) {
-      const row = stmt.getAsObject();
-      const name = row.name || "";
-      const filePath = row.file_path || "";
-      const sourceKey = name + filePath;
-      if (seen.has(sourceKey)) continue;
-      seen.add(sourceKey);
-      const lowerText = `${name} ${filePath}`.toLowerCase();
-      const matchedTerms = searchTerms.filter((t) => lowerText.includes(t));
-      const keywordScore = matchedTerms.length > 0 ? Math.round(matchedTerms.length / Math.max(1, searchTerms.length) * 100) : 0;
-      results.push({
-        source: name,
-        sourceType: "graph",
-        score: keywordScore,
-        keywordScore,
-        vectorScore: 0,
-        matchedTerms
-      });
-    }
-    stmt.free();
-  } catch (err) {
-    console.error(`[KumaSearch] DB search failed: ${err}`);
-  }
-  try {
-    const vectors = await buildSearchVectors();
-    for (const vec of vectors) {
-      const vectorScore = Math.round(cosineSimilarity(queryVector, vec.terms) * 100);
-      const existing = results.find((r) => r.source === vec.source);
-      if (existing) {
-        existing.vectorScore = vectorScore;
-        existing.score = Math.min(100, Math.round(existing.keywordScore * 0.6 + vectorScore * 0.4));
-        for (const [term] of vec.terms) {
-          if (queryVector.has(term) && !existing.matchedTerms.includes(term)) {
-            existing.matchedTerms.push(term);
-          }
-        }
-      } else if (vectorScore > 0) {
-        const matchedTerms = [];
-        for (const [term] of vec.terms) {
-          if (queryVector.has(term)) matchedTerms.push(term);
-        }
-        results.push({
-          source: vec.source,
-          sourceType: vec.sourceType,
-          score: Math.round(vectorScore * 0.4),
-          keywordScore: 0,
-          vectorScore,
-          matchedTerms
-        });
-      }
-    }
-  } catch (err) {
-    console.error(`[KumaSearch] Vector search failed: ${err}`);
-  }
-  const uniqueResults = Array.from(
-    new Map(results.map((r) => [r.source, r])).values()
-  );
-  return uniqueResults.sort((a, b) => b.score - a.score).slice(0, limit);
-}
-function formatHybridResults(query, results) {
-  const expandedTerms = expandQueryTerms(query);
-  const originalTerms = Array.from(expandedTerms.keys()).join(", ");
-  const totalSynonyms = Array.from(expandedTerms.values()).reduce(
-    (sum, s) => sum + s.size,
-    0
-  );
-  const lines = [
-    "**Hybrid Search** \u2014 " + query,
-    "----------------------------------------",
-    "",
-    "Expanded query: " + originalTerms + " (" + totalSynonyms + " total terms with synonyms)",
-    ""
-  ];
-  if (results.length === 0) {
-    lines.push("No results found. Try different keywords or research first.");
-    return lines.join("\n");
-  }
-  lines.push(results.length + " result(s) \u2014 ranked by hybrid relevance");
-  lines.push("");
-  for (let i = 0; i < results.length; i++) {
-    const r = results[i];
-    const typeIcon = r.sourceType === "graph" ? "file" : r.sourceType === "memory" ? "memory" : "research";
-    const matchType = r.vectorScore > r.keywordScore ? "semantic match" : r.keywordScore > 0 ? "keyword match" : "expanded match";
-    lines.push(i + 1 + ". [" + typeIcon + "] " + r.source + " \u2014 " + r.score + "%");
-    lines.push("   keyword: " + r.keywordScore + "% | vector: " + r.vectorScore + "% (" + matchType + ")");
-    if (r.matchedTerms.length > 0) {
-      lines.push("   Terms: " + r.matchedTerms.slice(0, 6).join(", "));
-    }
-    lines.push("");
-  }
-  lines.push("Hybrid search combines keyword matching with semantic synonym expansion.");
-  return lines.join("\n");
-}
-function clearSearchCache() {
-  _vectorCache = null;
-}
-export {
-  buildSearchVectors,
-  clearSearchCache,
-  expandQueryTerms,
-  formatHybridResults,
-  hybridSearch
-};