@plumpslabs/kuma 2.2.2 → 2.2.5

package/dist/index.js

@@ -100,13 +100,14 @@ async function handleSmartGrep(params) {
   const projectRoot = getProjectRoot();
   try {
     const searchPattern = targetFolder ? path.join(targetFolder, "**/*").replace(/\\/g, "/") : "**/*";
+    const targetDepth = targetFolder ? targetFolder.split("/").filter(Boolean).length : 0;
+    const maxDepth = targetFolder ? Math.min(targetDepth + 5, 20) : 10;
     let entries = await fg(searchPattern, {
       cwd: projectRoot,
       ignore: IGNORE_PATTERNS,
       onlyFiles: true,
       absolute: false,
-      deep: targetFolder ? 3 : 10,
-      // Batasi kedalaman
+      deep: maxDepth,
       dot: false
       // Skip dotfiles
     });
@@ -175,13 +176,14 @@ async function handleSmartGrep(params) {
   }
 }
 function createRegex(query) {
+  const normalized = query.replace(/\\\|/g, "|");
   try {
-    if (/[.\\+*?[\](){}^$|]/.test(query)) {
-      return new RegExp(query, "i");
+    if (/[.\\+*?[\](){}^$|]/.test(normalized)) {
+      return new RegExp(normalized, "i");
     }
   } catch {
   }
-  return new RegExp(query.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"), "i");
+  return new RegExp(normalized.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"), "i");
 }
 function formatResults(results, query, filesScanned) {
   if (results.length === 0) {
@@ -887,10 +889,10 @@ File "${filePath}" restored from backup: "${relBackupPath}".`;
 }
 async function handleCommitRollback(filePath, version) {
   try {
-    const { execSync: execSync9 } = await import("child_process");
+    const { execSync: execSync10 } = await import("child_process");
     const root = getProjectRoot();
     if (version === "list") {
-      const log = execSync9("git log --oneline -20", { cwd: root, encoding: "utf-8" });
+      const log = execSync10("git log --oneline -20", { cwd: root, encoding: "utf-8" });
       const lines = log.trim().split("\n").map((l) => `  ${l}`).join("\n");
       return [
         `\u{1F4CB} **Recent Commits:**`,
@@ -900,7 +902,7 @@ async function handleCommitRollback(filePath, version) {
         `\u{1F4A1} Use { action: "rollback", scope: "commit", version: <N> } to restore a specific commit.`
       ].join("\n");
     }
-    const status = execSync9("git status --porcelain", { cwd: root, encoding: "utf-8" }).trim();
+    const status = execSync10("git status --porcelain", { cwd: root, encoding: "utf-8" }).trim();
     if (status) {
       return [
         `\u26A0\uFE0F **Uncommitted changes detected.**`,
@@ -921,10 +923,10 @@ async function handleCommitRollback(filePath, version) {
       target = "HEAD~1";
     }
     if (filePath) {
-      execSync9(`git checkout ${target} -- "${filePath}"`, { cwd: root, encoding: "utf-8" });
+      execSync10(`git checkout ${target} -- "${filePath}"`, { cwd: root, encoding: "utf-8" });
       return `\u2705 **Commit Rollback** \u2014 File "${filePath}" restored from ${target}.`;
     } else {
-      execSync9(`git checkout ${target}`, { cwd: root, encoding: "utf-8" });
+      execSync10(`git checkout ${target}`, { cwd: root, encoding: "utf-8" });
       return `\u2705 **Commit Rollback** \u2014 Project restored to ${target}.`;
     }
   } catch (err) {
@@ -1214,8 +1216,10 @@ async function detectConventions(forceRescan = false) {
   }
   const projectRoot = getProjectRoot();
   const workspaces = detectWorkspaces(projectRoot);
+  const lang = detectLanguage(projectRoot);
+  const framework = lang !== "typescript" && lang !== "javascript" ? detectMultiLanguageFramework(projectRoot, lang) : detectFramework(projectRoot);
   const conventions = {
-    framework: detectFramework(projectRoot),
+    framework,
     projectType: detectProjectType(projectRoot),
     testRunner: detectTestRunner(projectRoot),
     styling: detectStyling(projectRoot),
@@ -1228,6 +1232,9 @@ async function detectConventions(forceRescan = false) {
     isMonorepo: workspaces.length > 0,
     workspaces
   };
+  if (lang !== "typescript" && lang !== "javascript") {
+    conventions.moduleSystem = "other";
+  }
   cachedConventions = conventions;
   return conventions;
 }
@@ -1504,13 +1511,169 @@ function detectModuleSystem(root) {
   return "cjs";
 }
 function detectLanguage(root) {
+  if (fs5.existsSync(path5.join(root, "go.mod"))) return "go";
+  if (fs5.existsSync(path5.join(root, "Cargo.toml"))) return "rust";
+  if (fs5.existsSync(path5.join(root, "composer.json"))) return "php";
+  if (fs5.existsSync(path5.join(root, "pyproject.toml")) || fs5.existsSync(path5.join(root, "requirements.txt")) || fs5.existsSync(path5.join(root, "setup.py"))) return "python";
+  if (fs5.existsSync(path5.join(root, "Gemfile"))) return "ruby";
+  if (fs5.existsSync(path5.join(root, "pom.xml"))) return "java";
+  if (fs5.existsSync(path5.join(root, "build.gradle")) || fs5.existsSync(path5.join(root, "build.gradle.kts"))) return "kotlin";
+  if (fs5.existsSync(path5.join(root, "Package.swift"))) return "swift";
+  try {
+    const entries = fs5.readdirSync(root);
+    if (entries.some((e) => e.endsWith(".csproj"))) return "csharp";
+  } catch {
+  }
   if (fs5.existsSync(path5.join(root, "tsconfig.json"))) return "typescript";
   const srcDir = path5.join(root, "src");
   if (fs5.existsSync(srcDir)) {
     const tsFiles = findFiles(srcDir, [".ts", ".tsx"]);
     if (tsFiles.length > 0) return "typescript";
+    const jsFiles = findFiles(srcDir, [".js", ".jsx"]);
+    if (jsFiles.length > 0) return "javascript";
+  }
+  try {
+    const tsFiles = findFiles(root, [".ts", ".tsx"]);
+    if (tsFiles.length > 0) return "typescript";
+    const jsFiles = findFiles(root, [".js", ".jsx"]);
+    if (jsFiles.length > 0) return "javascript";
+  } catch {
+  }
+  return "typescript";
+}
+function detectMultiLanguageFramework(root, language) {
+  switch (language) {
+    case "go": {
+      try {
+        const goMod = fs5.readFileSync(path5.join(root, "go.mod"), "utf-8");
+        if (goMod.includes("github.com/gin-gonic/gin")) return "Gin";
+        if (goMod.includes("github.com/labstack/echo")) return "Echo";
+        if (goMod.includes("github.com/gofiber/fiber")) return "Fiber";
+        if (goMod.includes("github.com/go-chi/chi")) return "Chi";
+        if (goMod.includes("github.com/gorilla/mux")) return "Gorilla Mux";
+        if (goMod.includes("github.com/urfave/cli")) return "CLI (urfave/cli)";
+        if (goMod.includes("github.com/spf13/cobra")) return "Cobra CLI";
+      } catch {
+      }
+      return "Go";
+    }
+    case "php": {
+      try {
+        const composer = JSON.parse(fs5.readFileSync(path5.join(root, "composer.json"), "utf-8"));
+        const req = composer.require ?? {};
+        const reqDev = composer["require-dev"] ?? {};
+        const deps = { ...req, ...reqDev };
+        if (deps["laravel/framework"]) return "Laravel";
+        if (deps["symfony/symfony"] || deps["symfony/framework-bundle"]) return "Symfony";
+        if (deps["codeigniter4/framework"]) return "CodeIgniter";
+        if (deps["yiisoft/yii2"]) return "Yii2";
+        if (deps["cakephp/cakephp"]) return "CakePHP";
+        if (deps["phalcon/incubator"]) return "Phalcon";
+        if (deps["wp-coding-standards/wpcs"]) return "WordPress";
+      } catch {
+      }
+      return "PHP";
+    }
+    case "python": {
+      try {
+        if (fs5.existsSync(path5.join(root, "pyproject.toml"))) {
+          const content = fs5.readFileSync(path5.join(root, "pyproject.toml"), "utf-8");
+          if (content.includes("django")) return "Django";
+          if (content.includes("flask")) return "Flask";
+          if (content.includes("fastapi")) return "FastAPI";
+        }
+        if (fs5.existsSync(path5.join(root, "requirements.txt"))) {
+          const content = fs5.readFileSync(path5.join(root, "requirements.txt"), "utf-8");
+          if (content.includes("django")) return "Django";
+          if (content.includes("flask")) return "Flask";
+          if (content.includes("fastapi")) return "FastAPI";
+          if (content.includes("tornado")) return "Tornado";
+          if (content.includes("aiohttp")) return "aiohttp";
+        }
+      } catch {
+      }
+      return "Python";
+    }
+    case "rust": {
+      try {
+        const cargo = fs5.readFileSync(path5.join(root, "Cargo.toml"), "utf-8");
+        if (cargo.includes("axum")) return "Axum";
+        if (cargo.includes("actix-web")) return "Actix Web";
+        if (cargo.includes("rocket")) return "Rocket";
+        if (cargo.includes("warp")) return "Warp";
+        if (cargo.includes("tide")) return "Tide";
+        if (cargo.includes("poem")) return "Poem";
+        if (cargo.includes("clap")) return "Clap CLI";
+      } catch {
+      }
+      return "Rust";
+    }
+    case "java": {
+      try {
+        const content = fs5.readFileSync(path5.join(root, "pom.xml"), "utf-8");
+        if (content.includes("spring-boot")) return "Spring Boot";
+        if (content.includes("quarkus")) return "Quarkus";
+        if (content.includes("micronaut")) return "Micronaut";
+        if (content.includes("jakarta")) return "Jakarta EE";
+        if (content.includes("helidon")) return "Helidon";
+      } catch {
+        try {
+          const gradle = fs5.readFileSync(path5.join(root, "build.gradle"), "utf-8");
+          if (gradle.includes("spring")) return "Spring Boot";
+          if (gradle.includes("quarkus")) return "Quarkus";
+        } catch {
+        }
+      }
+      return "Java";
+    }
+    case "kotlin": {
+      try {
+        const gradle = fs5.readFileSync(path5.join(root, "build.gradle.kts"), "utf-8");
+        if (gradle.includes("spring")) return "Spring Boot (Kotlin)";
+        if (gradle.includes("ktor")) return "Ktor";
+      } catch {
+      }
+      return "Kotlin";
+    }
+    case "ruby": {
+      try {
+        const gemfile = fs5.readFileSync(path5.join(root, "Gemfile"), "utf-8");
+        if (gemfile.includes("rails")) return "Ruby on Rails";
+        if (gemfile.includes("sinatra")) return "Sinatra";
+        if (gemfile.includes("hanami")) return "Hanami";
+        if (gemfile.includes("grape")) return "Grape API";
+      } catch {
+      }
+      return "Ruby";
+    }
+    case "csharp": {
+      try {
+        const entries = fs5.readdirSync(root);
+        const csproj = entries.find((e) => e.endsWith(".csproj"));
+        if (csproj) {
+          const content = fs5.readFileSync(path5.join(root, csproj), "utf-8");
+          if (content.includes("Microsoft.AspNetCore")) return "ASP.NET Core";
+          if (content.includes("Microsoft.Maui")) return ".NET MAUI";
+          if (content.includes("Serilog")) return "Serilog";
+        }
+      } catch {
+      }
+      return "C#";
+    }
+    case "swift": {
+      try {
+        const content = fs5.readFileSync(path5.join(root, "Package.swift"), "utf-8");
+        if (content.includes("vapor")) return "Vapor";
+        if (content.includes("swift-nio")) return "SwiftNIO";
+        if (content.includes("perfect")) return "Perfect";
+        if (content.includes("kitura")) return "Kitura";
+      } catch {
+      }
+      return "Swift";
+    }
+    default:
+      return detectFramework(root);
   }
-  return "javascript";
 }
 function detectFeatures(root) {
   const features = [];
@@ -7965,57 +8128,236 @@ function formatDecisionTemplate() {
 }
 
 // src/engine/kumaContextEngine.ts
-async function buildContextForGoal(goal) {
-  const items = [];
-  const terms = goal.toLowerCase().split(/\s+/).filter((w) => w.length > 2);
+import { execSync as execSync8 } from "child_process";
+var STOP_WORDS = /* @__PURE__ */ new Set([
+  "the",
+  "this",
+  "that",
+  "with",
+  "from",
+  "what",
+  "which",
+  "fix",
+  "bug",
+  "bikin",
+  "buat",
+  "add",
+  "new",
+  "need",
+  "make",
+  "want",
+  "can",
+  "get",
+  "set",
+  "use",
+  "using",
+  "would",
+  "could",
+  "should",
+  "have",
+  "has",
+  "had",
+  "for",
+  "and",
+  "not",
+  "but",
+  "are",
+  "was",
+  "were",
+  "all",
+  "any",
+  "each",
+  "every",
+  "some",
+  "find",
+  "show",
+  "list",
+  "create",
+  "update",
+  "delete",
+  "remove",
+  "change"
+]);
+function extractTerms(goal) {
+  const words = goal.toLowerCase().split(/[\s_\/-]+/).filter((w) => w.length > 2);
+  const filtered = words.filter((w) => !STOP_WORDS.has(w));
+  const unique = [...new Set(filtered)];
+  return unique.slice(0, 10);
+}
+async function searchNodesFts(db, terms) {
+  const results = [];
+  if (terms.length === 0) return results;
   try {
-    const db = await getDb();
-    for (const term of terms) {
+    const escaped = terms.map((t) => t.replace(/"/g, '""'));
+    const ftsQuery = escaped.map((t) => '"' + t + '"').join(" OR ");
+    const stmt = db.prepare(`
+      SELECT n.id, n.type, n.name, n.file_path, rank
+      FROM nodes_fts f
+      JOIN nodes n ON n.rowid = f.rowid
+      WHERE nodes_fts MATCH ?
+      ORDER BY rank
+      LIMIT 10
+    `);
+    stmt.bind([ftsQuery]);
+    while (stmt.step()) {
+      const row = stmt.getAsObject();
+      results.push({
+        id: row.id,
+        type: row.type,
+        name: row.name,
+        file_path: row.file_path,
+        rank: row.rank || 0
+      });
+    }
+    stmt.free();
+    return results;
+  } catch {
+  }
+  const seen = /* @__PURE__ */ new Set();
+  for (const term of terms) {
+    try {
       const stmt = db.prepare(`
         SELECT id, type, name, file_path FROM nodes
-        WHERE (name LIKE ? OR file_path LIKE ?)
+        WHERE name LIKE ? OR file_path LIKE ?
         ORDER BY updated_at DESC LIMIT 5
       `);
       stmt.bind([`%${term}%`, `%${term}%`]);
       while (stmt.step()) {
         const row = stmt.getAsObject();
-        items.push({
-          type: "graph",
-          label: row.name || "",
-          detail: `${row.type}: ${row.file_path || row.id}`,
-          priority: 80
-        });
+        const id = row.id;
+        if (!seen.has(id)) {
+          seen.add(id);
+          results.push({
+            id,
+            type: row.type,
+            name: row.name,
+            file_path: row.file_path,
+            rank: 0
+          });
+        }
       }
       stmt.free();
-      const edgeStmt = db.prepare(`
-        SELECT e.type, e.weight, n.name, n.file_path
-        FROM edges e
-        JOIN nodes n ON n.id = e.target_id
-        WHERE e.source_id LIKE ?
-        ORDER BY e.weight DESC LIMIT 5
-      `);
-      edgeStmt.bind([`%${term}%`]);
-      while (edgeStmt.step()) {
-        const row = edgeStmt.getAsObject();
-        items.push({
-          type: "graph",
-          label: row.name || "",
-          detail: `${row.type} (weight: ${row.weight})`,
-          priority: 60
-        });
+    } catch {
+    }
+  }
+  return results.slice(0, 10);
+}
+function getFileRecencySeconds(filePath) {
+  try {
+    const escapedPath = filePath.replace(/"/g, '\\"');
+    const result = execSync8(
+      'git log -1 --format=%ct -- "' + escapedPath + '" 2>/dev/null || echo 0',
+      { encoding: "utf-8", timeout: 2e3 }
+    );
+    const timestamp = parseInt(result.trim(), 10);
+    if (!timestamp || timestamp === 0) return null;
+    return Math.floor(Date.now() / 1e3) - timestamp;
+  } catch {
+    return null;
+  }
+}
+function calculatePriority(type, label, terms, recencySeconds) {
+  let score = 0;
+  switch (type) {
+    case "failure":
+      score = 90;
+      break;
+    case "file":
+      score = 60;
+      break;
+    case "graph":
+      score = 50;
+      break;
+    case "memory":
+      score = 40;
+      break;
+  }
+  const lower = label.toLowerCase();
+  for (const term of terms) {
+    if (lower === term) {
+      score += 30;
+    } else if (lower.includes(term)) {
+      score += 15;
+    }
+  }
+  if (recencySeconds !== null) {
+    if (recencySeconds < 3600) score += 20;
+    else if (recencySeconds < 86400) score += 10;
+    else if (recencySeconds < 604800) score += 5;
+  }
+  return Math.min(score, 100);
+}
+async function buildContextForGoal(goal) {
+  const items = [];
+  const terms = extractTerms(goal);
+  if (terms.length === 0) {
+    const modifiedFiles2 = sessionMemory.getModifiedFiles();
+    for (const mf of modifiedFiles2) {
+      items.push({
+        type: "file",
+        label: mf.filePath,
+        detail: "Modified (" + mf.status + ")",
+        priority: calculatePriority("file", mf.filePath, [], null)
+      });
+    }
+    return { context: items.slice(0, 15), summary: "\u{1F4CB} No specific terms in goal. Showing " + Math.min(items.length, 15) + " modified file(s)." };
+  }
+  try {
+    const db = await getDb();
+    const nodeResults = await searchNodesFts(db, terms);
+    const seenNodes = /* @__PURE__ */ new Set();
+    for (const node of nodeResults) {
+      if (seenNodes.has(node.id)) continue;
+      seenNodes.add(node.id);
+      const recency = node.file_path ? getFileRecencySeconds(node.file_path) : null;
+      const priority = calculatePriority("graph", node.name, terms, recency);
+      items.push({
+        type: "graph",
+        label: node.name,
+        detail: node.type + ": " + (node.file_path || node.id),
+        priority
+      });
+      if (nodeResults.indexOf(node) < 3) {
+        try {
+          const edgeStmt = db.prepare(`
+            SELECT e.type, e.weight, n.name, n.file_path
+            FROM edges e
+            JOIN nodes n ON n.id = e.target_id
+            WHERE e.source_id = ?
+            ORDER BY e.weight DESC LIMIT 3
+          `);
+          edgeStmt.bind([node.id]);
+          while (edgeStmt.step()) {
+            const row = edgeStmt.getAsObject();
+            const edgeName = row.name || "";
+            const edgeKey = "edge:" + edgeName;
+            if (!seenNodes.has(edgeKey)) {
+              seenNodes.add(edgeKey);
+              items.push({
+                type: "graph",
+                label: edgeName,
+                detail: row.type + " (weight: " + row.weight + ")",
+                priority: calculatePriority("graph", edgeName, terms, null) - 10
+              });
+            }
+          }
+          edgeStmt.free();
+        } catch {
+        }
       }
-      edgeStmt.free();
     }
   } catch {
   }
   const modifiedFiles = sessionMemory.getModifiedFiles();
   for (const mf of modifiedFiles) {
     if (terms.some((t) => mf.filePath.toLowerCase().includes(t))) {
+      const recency = getFileRecencySeconds(mf.filePath);
+      const priority = calculatePriority("file", mf.filePath, terms, recency);
       items.push({
         type: "file",
         label: mf.filePath,
-        detail: `Modified (${mf.status})`,
-        priority: 70
+        detail: "Modified (" + mf.status + ")",
+        priority
       });
     }
   }
@@ -8023,11 +8365,12 @@ async function buildContextForGoal(goal) {
   for (const ff of failedFiles) {
     for (const f of ff.failures) {
       if (!f.resolved && terms.some((t) => f.error.toLowerCase().includes(t))) {
+        const priority = calculatePriority("failure", ff.task, terms, null);
         items.push({
           type: "failure",
           label: ff.task,
           detail: f.error.substring(0, 120),
-          priority: 90
+          priority
         });
         break;
       }
@@ -8035,16 +8378,17 @@ async function buildContextForGoal(goal) {
   }
   const memories = scoreMemoryRelevance(goal, 3);
   for (const m of memories) {
+    const priority = calculatePriority("memory", m.topic, terms, null);
     items.push({
       type: "memory",
       label: m.topic,
       detail: m.content.substring(0, 100),
-      priority: m.score
+      priority
     });
   }
   const seen = /* @__PURE__ */ new Set();
   const unique = items.filter((i) => {
-    const key = `${i.type}:${i.label}`;
+    const key = i.type + ":" + i.label;
     if (seen.has(key)) return false;
     seen.add(key);
     return true;
@@ -8054,18 +8398,18 @@ async function buildContextForGoal(goal) {
   const fileCount = unique.filter((i) => i.type === "file").length;
   const failureCount = unique.filter((i) => i.type === "failure").length;
   const memoryCount = unique.filter((i) => i.type === "memory").length;
-  const summary = `\u{1F4CB} Context for "${goal.substring(0, 40)}": ${unique.length} items (${graphCount} graph, ${fileCount} files, ${failureCount} failures, ${memoryCount} memories)`;
+  const summary = '\u{1F4CB} Context for "' + goal.substring(0, 40) + '": ' + unique.length + " items (" + graphCount + " graph, " + fileCount + " files, " + failureCount + " failures, " + memoryCount + " memories)";
   return { context: unique.slice(0, 15), summary };
 }
 function formatContextItems(items, summary) {
   if (items.length === 0) return "";
   const lines = [
     summary,
-    "\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501"
+    "\u2501".repeat(25)
   ];
   for (const item of items) {
     const icon = item.type === "graph" ? "\u{1F517}" : item.type === "file" ? "\u{1F4C4}" : item.type === "failure" ? "\u274C" : item.type === "memory" ? "\u{1F9E0}" : "\u{1F4CC}";
-    lines.push(`  ${icon} **${item.label}** \u2014 ${item.detail}`);
+    lines.push("  " + icon + " **" + item.label + "** \u2014 " + item.detail);
   }
   return lines.join("\n");
 }
@@ -8832,7 +9176,7 @@ function countFiles(dir) {
 async function investigate(problem) {
   try {
     const db = await getDb();
-    const terms = extractTerms(problem);
+    const terms = extractTerms2(problem);
     const paths = [];
     const seen = /* @__PURE__ */ new Set();
     let step = 0;
@@ -8898,7 +9242,7 @@ async function investigate(problem) {
     return `Error investigating: ${err}`;
   }
 }
-function extractTerms(problem) {
+function extractTerms2(problem) {
   return problem.toLowerCase().replace(/[^a-z0-9\s]/g, "").split(/\s+/).filter((w) => w.length > 2 && !["the", "and", "for", "are", "but", "not", "you", "all", "can", "had", "her", "was", "one", "our", "out", "has", "have", "been", "some", "them", "then", "their", "this", "that", "with", "from", "they", "will", "would", "could", "should", "about", "into", "over", "after", "also", "does", "each", "made", "just", "more", "most", "much", "must", "only", "other", "such", "than", "very", "when", "where", "which", "while", "your", "fix", "bug", "slow", "error", "issue", "problem"].includes(w)).slice(0, 8);
 }
 function findBottlenecks(paths) {
@@ -10717,7 +11061,7 @@ function formatCollectivePatterns(patterns) {
 }
 
 // src/engine/kumaMarketplace.ts
-import { execSync as execSync8 } from "child_process";
+import { execSync as execSync9 } from "child_process";
 import fs27 from "fs";
 import path28 from "path";
 var BUILT_IN_TEMPLATES = [
@@ -11103,7 +11447,7 @@ async function tryInstallFromNpm(templateId) {
   try {
     const npmPackage = `@kuma-templates/${name}`;
     const root = getProjectRoot();
-    execSync8(`npm install --no-save ${npmPackage}`, {
+    execSync9(`npm install --no-save ${npmPackage}`, {
       cwd: root,
       encoding: "utf-8",
       timeout: 3e4,
@@ -11761,7 +12105,113 @@ async function handleAdvanced(action, params) {
   }
 }
 
+// src/utils/kumaOutput.ts
+import crypto3 from "crypto";
+var dedupCache = /* @__PURE__ */ new Map();
+var DEDUP_TTL_MS = 6e4;
+function getCachedOutput(key) {
+  const entry = dedupCache.get(key);
+  if (entry && Date.now() - entry.timestamp < DEDUP_TTL_MS) {
+    return entry.output;
+  }
+  return null;
+}
+function setCachedOutput(key, output) {
+  dedupCache.set(key, { output, timestamp: Date.now() });
+  if (dedupCache.size > 50) {
+    const now = Date.now();
+    for (const [k, v] of dedupCache) {
+      if (now - v.timestamp > DEDUP_TTL_MS) dedupCache.delete(k);
+    }
+  }
+}
+function buildCacheKey(toolName, params) {
+  const stable = {};
+  for (const key of Object.keys(params).sort()) {
+    const val = params[key];
+    if (typeof val === "string") stable[key] = val.trim().substring(0, 200);
+    else if (typeof val === "number") stable[key] = val;
+    else if (typeof val === "boolean") stable[key] = val;
+    else if (Array.isArray(val)) stable[key] = val.length;
+    else if (val === null || val === void 0) stable[key] = null;
+    else stable[key] = JSON.stringify(val).substring(0, 200);
+  }
+  const str = JSON.stringify(stable);
+  return toolName + ":" + crypto3.createHash("md5").update(str).digest("hex").substring(0, 12);
+}
+var EMOJI_PATTERN = /[\u{1F000}-\u{1FFFF}\u{2600}-\u{26FF}\u{2700}-\u{27BF}\u{2300}-\u{23FF}]/gu;
+var BOLD_PATTERN = /\*\*/g;
+var DECORATIVE_LINE = /[━┉═]{5,}/g;
+var MULTI_NEWLINE = /\n{3,}/g;
+function stripFormatting(text) {
+  return text.replace(EMOJI_PATTERN, "").replace(BOLD_PATTERN, "").replace(DECORATIVE_LINE, "").replace(MULTI_NEWLINE, "\n\n").split("\n").map((l) => l.trim()).join("\n").trim();
+}
+function adaptiveCompress(text, tokenBudget) {
+  const lines = text.split("\n");
+  const estimatedTokens = estimateTokens(text);
+  if (!tokenBudget || estimatedTokens <= tokenBudget) return text;
+  const stripped = stripFormatting(text);
+  const strippedTokens = estimateTokens(stripped);
+  if (strippedTokens <= tokenBudget) return stripped;
+  if (lines.length < 50) {
+    const maxChars = tokenBudget * 3;
+    return stripped.slice(0, maxChars) + `
+
+[...truncated: ~${estimatedTokens}tokens > ${tokenBudget}tokens]`;
+  }
+  if (lines.length < 200) {
+    const head = lines.slice(0, 30).join("\n");
+    const tail = lines.slice(-10).join("\n");
+    return `${stripFormatting(head)}
+
+[...${lines.length - 40} lines hidden - ${estimatedTokens}tokens > ${tokenBudget}tokens]
+
+${stripFormatting(tail)}`;
+  }
+  const summaryLines = lines.filter((l) => {
+    const t = l.trim();
+    return t.length > 10 && !t.startsWith("  ") && !t.startsWith(".") && !/^[━┉═\s]+$/.test(t);
+  });
+  const compressed = stripFormatting(summaryLines.slice(0, 20).join("\n"));
+  return `${compressed}
+
+[...${lines.length} lines compressed to ${summaryLines.length} key lines - ~${estimatedTokens}tokens > ${tokenBudget}tokens]`;
+}
+function formatOutput2(text, options = {}) {
+  const { compact, responseBudget } = options;
+  let result = text;
+  if (options.cacheKey) {
+    const cached = getCachedOutput(options.cacheKey);
+    if (cached !== null) {
+      return cached;
+    }
+  }
+  if (compact) {
+    result = stripFormatting(result);
+  }
+  if (responseBudget && responseBudget > 0) {
+    const tokens = estimateTokens(result);
+    if (tokens > responseBudget) {
+      result = adaptiveCompress(result, responseBudget);
+    }
+  }
+  if (options.cacheKey) {
+    setCachedOutput(options.cacheKey, result);
+  }
+  return result;
+}
+
 // src/manifest.ts
+function wrapOutput(text, toolName, params) {
+  const compact = params.compact === true;
+  const responseBudget = params.responseBudget;
+  const cacheKey = buildCacheKey(toolName, params);
+  return formatOutput2(text, { compact, responseBudget, cacheKey });
+}
+var compactSchema = {
+  compact: z.boolean().optional().default(false).describe("Compact output mode (strips emojis/formatting, saves ~50% tokens)"),
+  responseBudget: z.number().min(100).max(1e4).optional().describe("Max tokens for response (auto-compresses if exceeded)")
+};
 function registerAllTools(server) {
   server.tool(
     "kuma_init",
@@ -11770,12 +12220,13 @@ function registerAllTools(server) {
       action: z.enum(["init", "conventions", "structure"]).default("init").describe("Action: init=load all context, conventions=detect stack, structure=show tree"),
       projectRoot: z.string().optional().describe("Project root path (auto-detected)"),
       forceRescan: z.boolean().optional().default(false).describe("Force rescan for conventions"),
-      depth: z.number().min(1).max(6).optional().default(3).describe("Tree depth for structure")
+      depth: z.number().min(1).max(6).optional().default(3).describe("Tree depth for structure"),
+      ...compactSchema
     },
     async (params) => {
       try {
         const text = await handleInit(params.action || "init", params);
-        return { content: [{ type: "text", text }] };
+        return { content: [{ type: "text", text: wrapOutput(text, "kuma_init", params) }] };
       } catch (err) {
         return { content: [{ type: "text", text: `Error in kuma_init: ${err}` }], isError: true };
       }
@@ -11820,17 +12271,18 @@ function registerAllTools(server) {
       line: z.number().min(0).optional().describe("Line number (0-indexed) for LSP"),
       character: z.number().min(0).optional().describe("Character position (0-indexed) for LSP"),
       lspAction: z.enum(["def", "refs", "type", "rename"]).optional().describe("LSP sub-action"),
-      newName: z.string().optional().describe("New name for rename action")
+      newName: z.string().optional().describe("New name for rename action"),
+      ...compactSchema
     },
     async (params) => {
       try {
         const action = params.action || "grep";
         if (action === "edit") {
           const text2 = await safeEditHandler(params);
-          return { content: [{ type: "text", text: text2 }] };
+          return { content: [{ type: "text", text: wrapOutput(text2, "kuma_core", params) }] };
         }
         const text = await handleCore(action, params);
-        return { content: [{ type: "text", text }] };
+        return { content: [{ type: "text", text: wrapOutput(text, "kuma_core", params) }] };
       } catch (err) {
         return { content: [{ type: "text", text: `Error in kuma_core: ${err}` }], isError: true };
       }
@@ -11854,12 +12306,13 @@ function registerAllTools(server) {
       format: z.enum(["text", "json"]).optional().default("text").describe("Output format"),
       // lint params
       tool: z.enum(["eslint", "tsc", "prettier", "ruff", "all"]).optional().default("all").describe("Lint tool"),
-      autoFix: z.boolean().optional().default(false).describe("Auto-fix issues")
+      autoFix: z.boolean().optional().default(false).describe("Auto-fix issues"),
+      ...compactSchema
     },
     async (params) => {
       try {
         const text = await handleVerify(params.action || "test", params);
-        return { content: [{ type: "text", text }] };
+        return { content: [{ type: "text", text: wrapOutput(text, "kuma_verify", params) }] };
       } catch (err) {
         return { content: [{ type: "text", text: `Error in kuma_verify: ${err}` }], isError: true };
       }
@@ -11880,7 +12333,8 @@ function registerAllTools(server) {
       check: z.enum(["all", "anti-pattern", "loop", "drift", "context"]).optional().default("all").describe("Guard check type"),
       packageName: z.string().optional().describe("Package name for dependency guard"),
       packageVersion: z.string().optional().describe("Package version for dependency guard"),
-      actionCheck: z.string().optional().describe("Check sub-action (e.g. 'edit')")
+      actionCheck: z.string().optional().describe("Check sub-action (e.g. 'edit')"),
+      ...compactSchema
     },
     async (params) => {
       try {
@@ -11890,7 +12344,7 @@ function registerAllTools(server) {
           actionCheck: params.actionCheck || params.action,
           contextAction: params.contextAction || (action === "context" ? "save" : void 0)
         });
-        return { content: [{ type: "text", text }] };
+        return { content: [{ type: "text", text: wrapOutput(text, "kuma_safety", params) }] };
       } catch (err) {
         return { content: [{ type: "text", text: `Error in kuma_safety: ${err}` }], isError: true };
       }
@@ -11912,12 +12366,13 @@ function registerAllTools(server) {
       experienceAction: z.enum(["suggest", "errors", "prune"]).optional().describe("Experience sub-action"),
       toolName: z.string().optional().describe("Tool name for experience errors"),
       intentAction: z.enum(["suggest"]).optional().describe("Intent sub-action"),
-      intent: z.string().optional().describe("Intent description")
+      intent: z.string().optional().describe("Intent description"),
+      ...compactSchema
     },
     async (params) => {
       try {
         const text = await handleGraph(params.action || "query", params);
-        return { content: [{ type: "text", text }] };
+        return { content: [{ type: "text", text: wrapOutput(text, "kuma_graph", params) }] };
       } catch (err) {
         return { content: [{ type: "text", text: `Error in kuma_graph: ${err}` }], isError: true };
       }
@@ -11938,12 +12393,13 @@ function registerAllTools(server) {
       title: z.string().optional().describe("Decision title for record"),
       rationale: z.string().optional().describe("Decision rationale for record"),
       outcome: z.string().optional().describe("Decision outcome for record"),
-      healAction: z.enum(["check", "heal"]).optional().default("heal").describe("Heal sub-action")
+      healAction: z.enum(["check", "heal"]).optional().default("heal").describe("Heal sub-action"),
+      ...compactSchema
     },
     async (params) => {
       try {
         const text = await handleMemory(params.action || "get", params);
-        return { content: [{ type: "text", text }] };
+        return { content: [{ type: "text", text: wrapOutput(text, "kuma_memory", params) }] };
       } catch (err) {
         return { content: [{ type: "text", text: `Error in kuma_memory: ${err}` }], isError: true };
       }
@@ -11957,12 +12413,13 @@ function registerAllTools(server) {
       goal: z.string().optional().describe("Goal for reflect"),
       context: z.string().optional().describe("Context for predict"),
       target: z.string().optional().describe("Target for confidence"),
-      sessionStats: z.boolean().optional().default(false).describe("Include session stats in heatmap")
+      sessionStats: z.boolean().optional().default(false).describe("Include session stats in heatmap"),
+      ...compactSchema
     },
     async (params) => {
       try {
         const text = await handleAnalytics(params.action || "reflect", params);
-        return { content: [{ type: "text", text }] };
+        return { content: [{ type: "text", text: wrapOutput(text, "kuma_analytics", params) }] };
       } catch (err) {
         return { content: [{ type: "text", text: `Error in kuma_analytics: ${err}` }], isError: true };
       }
@@ -11981,12 +12438,13 @@ function registerAllTools(server) {
       staged: z.boolean().optional().default(false).describe("Show staged changes for diff"),
       contextLines: z.number().min(1).max(20).optional().default(3).describe("Context lines for diff"),
       baseRef: z.string().optional().describe("Base git ref for diff"),
-      targetRef: z.string().optional().describe("Target git ref for diff")
+      targetRef: z.string().optional().describe("Target git ref for diff"),
+      ...compactSchema
     },
     async (params) => {
       try {
         const text = await handleHistory(params.action || "log", params);
-        return { content: [{ type: "text", text }] };
+        return { content: [{ type: "text", text: wrapOutput(text, "kuma_history", params) }] };
       } catch (err) {
         return { content: [{ type: "text", text: `Error in kuma_history: ${err}` }], isError: true };
       }
@@ -11998,12 +12456,13 @@ function registerAllTools(server) {
     {
       action: z.enum(["acquire", "release", "list", "clean"]).describe("Lock action"),
       filePath: z.string().optional().describe("File path for acquire/release"),
-      agentId: z.string().optional().describe("Agent identifier for lock")
+      agentId: z.string().optional().describe("Agent identifier for lock"),
+      ...compactSchema
     },
     async (params) => {
       try {
         const text = await handleLock(params.action || "list", params);
-        return { content: [{ type: "text", text }] };
+        return { content: [{ type: "text", text: wrapOutput(text, "kuma_lock", params) }] };
       } catch (err) {
         return { content: [{ type: "text", text: `Error in kuma_lock: ${err}` }], isError: true };
       }
@@ -12030,12 +12489,13 @@ function registerAllTools(server) {
       marketplaceAction: z.enum(["list", "install"]).optional().describe("Marketplace sub-action"),
       template: z.string().optional().describe("Template ID for marketplace install"),
       // query params
-      query: z.string().optional().describe("Query for failure query")
+      query: z.string().optional().describe("Query for failure query"),
+      ...compactSchema
     },
     async (params) => {
       try {
         const text = await handleAdvanced(params.action || "marketplace", params);
-        return { content: [{ type: "text", text }] };
+        return { content: [{ type: "text", text: wrapOutput(text, "kuma_advanced", params) }] };
       } catch (err) {
         return { content: [{ type: "text", text: `Error in kuma_advanced: ${err}` }], isError: true };
       }