kiro-memory 1.2.0 → 1.2.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kiro-memory",
-  "version": "1.2.0",
+  "version": "1.2.2",
   "description": "Persistent cross-session memory for Kiro CLI. Automatically tracks context, observations, and summaries across coding sessions.",
   "keywords": [
     "kiro",

package/plugin/dist/cli/contextkit.js

@@ -1082,16 +1082,63 @@ function createContextKit(config) {
 
 // src/cli/contextkit.ts
 import { execSync } from "child_process";
-import { existsSync as existsSync3, mkdirSync as mkdirSync3, readFileSync as readFileSync2, writeFileSync, copyFileSync } from "fs";
+import { existsSync as existsSync3, mkdirSync as mkdirSync3, readFileSync as readFileSync2, writeFileSync, appendFileSync as appendFileSync2 } from "fs";
 import { join as join3, dirname as dirname2 } from "path";
 import { homedir as homedir3, platform, release } from "os";
 import { fileURLToPath as fileURLToPath2 } from "url";
+import { createInterface } from "readline";
 var args = process.argv.slice(2);
 var command = args[0];
 var __filename = fileURLToPath2(import.meta.url);
 var __dirname2 = dirname2(__filename);
 var DIST_DIR = dirname2(__dirname2);
-var PROJECT_ROOT = dirname2(dirname2(DIST_DIR));
+var AGENT_TEMPLATE = JSON.stringify({
+  name: "contextkit-memory",
+  description: "Agent with persistent cross-session memory. Uses ContextKit to remember context from previous sessions and automatically save what it learns.",
+  model: "claude-sonnet-4",
+  tools: ["read", "write", "shell", "glob", "grep", "web_search", "web_fetch", "@contextkit"],
+  mcpServers: {
+    contextkit: {
+      command: "node",
+      args: ["__DIST_DIR__/servers/mcp-server.js"]
+    }
+  },
+  hooks: {
+    agentSpawn: [{ command: "node __DIST_DIR__/hooks/agentSpawn.js", timeout_ms: 1e4 }],
+    userPromptSubmit: [{ command: "node __DIST_DIR__/hooks/userPromptSubmit.js", timeout_ms: 5e3 }],
+    postToolUse: [{ command: "node __DIST_DIR__/hooks/postToolUse.js", matcher: "*", timeout_ms: 5e3 }],
+    stop: [{ command: "node __DIST_DIR__/hooks/stop.js", timeout_ms: 1e4 }]
+  },
+  resources: ["file://.kiro/steering/contextkit.md"]
+}, null, 2);
+var STEERING_CONTENT = `# ContextKit - Persistent Memory
+
+You have access to ContextKit, a persistent cross-session memory system.
+
+## Available MCP Tools
+
+### @contextkit/search
+Search previous session memory. Use when:
+- The user mentions past work
+- You need context on previous decisions
+- You want to check if a problem was already addressed
+
+### @contextkit/get_context
+Retrieve recent context for the current project. Use at the start of complex tasks to understand what was done before.
+
+### @contextkit/timeline
+Show chronological context around an observation. Use to understand the sequence of events.
+
+### @contextkit/get_observations
+Retrieve full details of specific observations. Use after \`search\` to drill down.
+
+## Behavior
+
+- Previous session context is automatically injected at startup
+- Your actions (files written, commands run) are tracked automatically
+- A summary is generated at the end of each session
+- No manual saving needed: the system is fully automatic
+`;
 function isWSL() {
   try {
     const rel = release().toLowerCase();
@@ -1113,44 +1160,58 @@ function commandExists(cmd) {
     return false;
   }
 }
+function isWindowsPath(p) {
+  return p.startsWith("/mnt/c") || p.startsWith("/mnt/d") || /^[A-Za-z]:[\\\/]/.test(p);
+}
 function runEnvironmentChecks() {
   const checks = [];
   const wsl = isWSL();
   const os = platform();
   checks.push({
-    name: "Sistema operativo",
+    name: "Operating system",
     ok: os === "linux" || os === "darwin",
-    message: os === "linux" ? wsl ? "Linux (WSL)" : "Linux" : os === "darwin" ? "macOS" : `${os} (non supportato ufficialmente)`
+    message: os === "linux" ? wsl ? "Linux (WSL)" : "Linux" : os === "darwin" ? "macOS" : `${os} (not officially supported)`
   });
   if (wsl) {
     const nodePath = process.execPath;
-    const nodeOnWindows = nodePath.startsWith("/mnt/c") || nodePath.startsWith("/mnt/d");
+    const nodeOnWindows = isWindowsPath(nodePath);
     checks.push({
-      name: "WSL: Node.js nativo",
+      name: "WSL: Native Node.js",
       ok: !nodeOnWindows,
-      message: nodeOnWindows ? `Node.js punta a Windows: ${nodePath}` : `Node.js nativo Linux: ${nodePath}`,
-      fix: nodeOnWindows ? "Installa Node.js dentro WSL:\n  curl -fsSL https://deb.nodesource.com/setup_22.x | sudo -E bash -\n  sudo apt-get install -y nodejs\n  Oppure usa nvm: https://github.com/nvm-sh/nvm" : void 0
+      message: nodeOnWindows ? `Node.js points to Windows: ${nodePath}` : `Native Linux Node.js: ${nodePath}`,
+      fix: nodeOnWindows ? "Install Node.js inside WSL:\n  curl -fsSL https://deb.nodesource.com/setup_22.x | sudo -E bash -\n  sudo apt-get install -y nodejs\n  Or use nvm: https://github.com/nvm-sh/nvm" : void 0
     });
     try {
       const npmPrefix = execSync("npm prefix -g", { encoding: "utf8" }).trim();
-      const prefixOnWindows = npmPrefix.startsWith("/mnt/c") || npmPrefix.startsWith("/mnt/d");
+      const prefixOnWindows = isWindowsPath(npmPrefix);
       checks.push({
         name: "WSL: npm global prefix",
         ok: !prefixOnWindows,
-        message: prefixOnWindows ? `npm global prefix punta a Windows: ${npmPrefix}` : `npm global prefix: ${npmPrefix}`,
-        fix: prefixOnWindows ? `Correggi il prefix npm:
+        message: prefixOnWindows ? `npm global prefix points to Windows: ${npmPrefix}` : `npm global prefix: ${npmPrefix}`,
+        fix: prefixOnWindows ? `Fix npm prefix:
   mkdir -p ~/.npm-global
   npm config set prefix ~/.npm-global
   echo 'export PATH="$HOME/.npm-global/bin:$PATH"' >> ~/.bashrc
   source ~/.bashrc
-  Poi reinstalla: npm install -g kiro-memory` : void 0
+  Then reinstall: npm install -g kiro-memory` : void 0
       });
     } catch {
       checks.push({
         name: "WSL: npm global prefix",
         ok: false,
-        message: "Impossibile determinare npm prefix"
+        message: "Unable to determine npm prefix"
+      });
+    }
+    try {
+      const npmPath = execSync("which npm", { encoding: "utf8" }).trim();
+      const npmOnWindows = isWindowsPath(npmPath);
+      checks.push({
+        name: "WSL: npm binary",
+        ok: !npmOnWindows,
+        message: npmOnWindows ? `npm is the Windows version: ${npmPath}` : `Native Linux npm: ${npmPath}`,
+        fix: npmOnWindows ? "Your npm binary is the Windows version running inside WSL.\n  This causes EPERM/UNC errors when installing packages.\n  Install Node.js (includes npm) natively in WSL:\n    curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.40.1/install.sh | bash\n    source ~/.bashrc\n    nvm install 22\n  Or:\n    curl -fsSL https://deb.nodesource.com/setup_22.x | sudo -E bash -\n    sudo apt-get install -y nodejs" : void 0
       });
+    } catch {
     }
   }
   const nodeVersion = parseInt(process.versions.node.split(".")[0]);
@@ -1158,22 +1219,22 @@ function runEnvironmentChecks() {
     name: "Node.js >= 18",
     ok: nodeVersion >= 18,
     message: `Node.js v${process.versions.node}`,
-    fix: nodeVersion < 18 ? "Aggiorna Node.js:\n  nvm install 22 && nvm use 22\n  Oppure: https://nodejs.org/" : void 0
+    fix: nodeVersion < 18 ? "Upgrade Node.js:\n  nvm install 22 && nvm use 22\n  Or visit: https://nodejs.org/" : void 0
   });
   let sqliteOk = false;
   let sqliteMsg = "";
   try {
     __require("better-sqlite3");
     sqliteOk = true;
-    sqliteMsg = "Modulo nativo caricato correttamente";
+    sqliteMsg = "Native module loaded successfully";
   } catch (err) {
-    sqliteMsg = err.code === "ERR_DLOPEN_FAILED" ? "Binario nativo incompatibile (ELF header invalido \u2014 probabile mismatch piattaforma)" : `Errore: ${err.message}`;
+    sqliteMsg = err.code === "ERR_DLOPEN_FAILED" ? "Incompatible native binary (invalid ELF header \u2014 likely platform mismatch)" : `Error: ${err.message}`;
   }
   checks.push({
     name: "better-sqlite3",
     ok: sqliteOk,
     message: sqliteMsg,
-    fix: !sqliteOk ? wsl ? "In WSL, ricompila il modulo nativo:\n  npm rebuild better-sqlite3\n  Se non funziona, reinstalla:\n  npm install -g kiro-memory --build-from-source" : "Reinstalla il modulo nativo:\n  npm rebuild better-sqlite3" : void 0
+    fix: !sqliteOk ? wsl ? "In WSL, rebuild the native module:\n  npm rebuild better-sqlite3\n  If that fails, reinstall:\n  npm install -g kiro-memory --build-from-source" : "Rebuild the native module:\n  npm rebuild better-sqlite3" : void 0
   });
   if (os === "linux") {
     const hasMake = commandExists("make");
@@ -1184,12 +1245,12 @@ function runEnvironmentChecks() {
     if (!hasMake || !hasGcc) missing.push("build-essential");
     if (!hasPython) missing.push("python3");
     checks.push({
-      name: "Build tools (moduli nativi)",
+      name: "Build tools (native modules)",
       ok: allPresent,
-      message: allPresent ? "make, g++, python3 disponibili" : `Mancanti: ${missing.join(", ")}`,
-      fix: !allPresent ? `Installa i pacchetti richiesti:
+      message: allPresent ? "make, g++, python3 available" : `Missing: ${missing.join(", ")}`,
+      fix: !allPresent ? `Install required packages:
   sudo apt-get update && sudo apt-get install -y ${missing.join(" ")}
-  Poi reinstalla: npm install -g kiro-memory --build-from-source` : void 0
+  Then reinstall: npm install -g kiro-memory --build-from-source` : void 0
     });
   }
   return checks;
@@ -1211,35 +1272,42 @@ function printChecks(checks) {
   console.log("");
   return { hasErrors };
 }
+function askUser(question) {
+  const rl = createInterface({ input: process.stdin, output: process.stdout });
+  return new Promise((resolve) => {
+    rl.question(question, (answer) => {
+      rl.close();
+      resolve(answer.trim().toLowerCase());
+    });
+  });
+}
+function detectShellRc() {
+  const shell = process.env.SHELL || "/bin/bash";
+  if (shell.includes("zsh")) return { name: "zsh", rcFile: join3(homedir3(), ".zshrc") };
+  if (shell.includes("fish")) return { name: "fish", rcFile: join3(homedir3(), ".config/fish/config.fish") };
+  return { name: "bash", rcFile: join3(homedir3(), ".bashrc") };
+}
 async function installKiro() {
-  console.log("\n=== Kiro Memory - Installazione ===\n");
-  console.log("[1/3] Diagnostica ambiente...");
+  console.log("\n=== Kiro Memory - Installation ===\n");
+  console.log("[1/3] Running environment checks...");
   const checks = runEnvironmentChecks();
   const { hasErrors } = printChecks(checks);
   if (hasErrors) {
-    console.log("\x1B[31mInstallazione annullata.\x1B[0m Risolvi i problemi sopra e riprova.");
-    console.log("Dopo aver risolto, esegui: kiro-memory install\n");
+    console.log("\x1B[31mInstallation aborted.\x1B[0m Fix the issues above and retry.");
+    console.log("After fixing, run: kiro-memory install\n");
     process.exit(1);
   }
   const distDir = DIST_DIR;
-  const agentTemplatePath = join3(PROJECT_ROOT, "kiro-agent", "contextkit.json");
-  const steeringSourcePath = join3(PROJECT_ROOT, "kiro-agent", "steering.md");
-  if (!existsSync3(agentTemplatePath)) {
-    console.error(`\x1B[31mErrore:\x1B[0m Template agent non trovato: ${agentTemplatePath}`);
-    console.error("Prova a reinstallare: npm install -g kiro-memory");
-    process.exit(1);
-  }
   const kiroDir = process.env.KIRO_CONFIG_DIR || join3(homedir3(), ".kiro");
   const agentsDir = join3(kiroDir, "agents");
   const settingsDir = join3(kiroDir, "settings");
   const steeringDir = join3(kiroDir, "steering");
   const dataDir = process.env.CONTEXTKIT_DATA_DIR || join3(homedir3(), ".contextkit");
-  console.log("[2/3] Installazione configurazione Kiro...\n");
+  console.log("[2/3] Installing Kiro configuration...\n");
   for (const dir of [agentsDir, settingsDir, steeringDir, dataDir]) {
     mkdirSync3(dir, { recursive: true });
   }
-  const agentTemplate = readFileSync2(agentTemplatePath, "utf8");
-  const agentConfig = agentTemplate.replace(/__CONTEXTKIT_DIST__/g, distDir);
+  const agentConfig = AGENT_TEMPLATE.replace(/__DIST_DIR__/g, distDir);
   const agentDestPath = join3(agentsDir, "contextkit.json");
   writeFileSync(agentDestPath, agentConfig, "utf8");
   console.log(`  \u2192 Agent config: ${agentDestPath}`);
@@ -1259,33 +1327,73 @@ async function installKiro() {
   writeFileSync(mcpFilePath, JSON.stringify(mcpConfig, null, 2), "utf8");
   console.log(`  \u2192 MCP config:   ${mcpFilePath}`);
   const steeringDestPath = join3(steeringDir, "contextkit.md");
-  if (existsSync3(steeringSourcePath)) {
-    copyFileSync(steeringSourcePath, steeringDestPath);
-    console.log(`  \u2192 Steering:     ${steeringDestPath}`);
-  }
+  writeFileSync(steeringDestPath, STEERING_CONTENT, "utf8");
+  console.log(`  \u2192 Steering:     ${steeringDestPath}`);
   console.log(`  \u2192 Data dir:     ${dataDir}`);
-  console.log("\n[3/3] Installazione completata!\n");
-  console.log("Per usare Kiro con memoria persistente:");
-  console.log("  kiro-cli --agent contextkit-memory\n");
-  console.log("Per creare un alias permanente:");
-  console.log(`  echo 'alias kiro="kiro-cli --agent contextkit-memory"' >> ~/.bashrc`);
-  console.log("  source ~/.bashrc\n");
-  console.log("Il worker si avvia automaticamente alla prima sessione.");
-  console.log(`Dashboard web: http://localhost:3001
+  console.log("\n[3/3] Shell alias setup\n");
+  const { name: shellName, rcFile } = detectShellRc();
+  const aliasLine = 'alias kiro="kiro-cli --agent contextkit-memory"';
+  let aliasAlreadySet = false;
+  if (existsSync3(rcFile)) {
+    const rcContent = readFileSync2(rcFile, "utf8");
+    aliasAlreadySet = rcContent.includes("alias kiro=") && rcContent.includes("contextkit-memory");
+  }
+  if (aliasAlreadySet) {
+    console.log(`  \x1B[32m\u2713\x1B[0m Alias already configured in ${rcFile}`);
+  } else {
+    console.log("  \x1B[36m\u250C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2510\x1B[0m");
+    console.log("  \x1B[36m\u2502\x1B[0m  Without an alias, you must type every time:            \x1B[36m\u2502\x1B[0m");
+    console.log("  \x1B[36m\u2502\x1B[0m    \x1B[2mkiro-cli --agent contextkit-memory\x1B[0m                    \x1B[36m\u2502\x1B[0m");
+    console.log("  \x1B[36m\u2502\x1B[0m                                                         \x1B[36m\u2502\x1B[0m");
+    console.log("  \x1B[36m\u2502\x1B[0m  With the alias, just type:                              \x1B[36m\u2502\x1B[0m");
+    console.log("  \x1B[36m\u2502\x1B[0m    \x1B[1m\x1B[32mkiro\x1B[0m                                                 \x1B[36m\u2502\x1B[0m");
+    console.log("  \x1B[36m\u2514\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2518\x1B[0m");
+    console.log("");
+    const answer = await askUser(`  Add alias to ${rcFile}? [Y/n] `);
+    if (answer === "" || answer === "y" || answer === "yes") {
+      try {
+        appendFileSync2(rcFile, `
+# Kiro Memory \u2014 persistent memory alias
+${aliasLine}
+`);
+        console.log(`
+  \x1B[32m\u2713\x1B[0m Alias added to ${rcFile}`);
+        console.log(`  \x1B[33m\u2192\x1B[0m Run \x1B[1msource ${rcFile}\x1B[0m or open a new terminal to activate it.`);
+      } catch (err) {
+        console.log(`
+  \x1B[31m\u2717\x1B[0m Could not write to ${rcFile}: ${err.message}`);
+        console.log(`  \x1B[33m\u2192\x1B[0m Add manually: ${aliasLine}`);
+      }
+    } else {
+      console.log(`
+  Skipped. You can add it manually later:`);
+      console.log(`    echo '${aliasLine}' >> ${rcFile}`);
+    }
+  }
+  console.log("\n\x1B[32m\u2550\u2550\u2550 Installation complete! \u2550\u2550\u2550\x1B[0m\n");
+  console.log("  Start Kiro with memory:");
+  if (aliasAlreadySet) {
+    console.log("    \x1B[1mkiro\x1B[0m");
+  } else {
+    console.log("    \x1B[1mkiro-cli --agent contextkit-memory\x1B[0m");
+  }
+  console.log("");
+  console.log("  The worker starts automatically when a Kiro session begins.");
+  console.log(`  Web dashboard: \x1B[4mhttp://localhost:3001\x1B[0m
 `);
 }
 async function runDoctor() {
-  console.log("\n=== Kiro Memory - Diagnostica ===");
+  console.log("\n=== Kiro Memory - Diagnostics ===");
   const checks = runEnvironmentChecks();
   const kiroDir = process.env.KIRO_CONFIG_DIR || join3(homedir3(), ".kiro");
   const agentPath = join3(kiroDir, "agents", "contextkit.json");
   const mcpPath = join3(kiroDir, "settings", "mcp.json");
   const dataDir = process.env.CONTEXTKIT_DATA_DIR || join3(homedir3(), ".contextkit");
   checks.push({
-    name: "Agent config Kiro",
+    name: "Kiro agent config",
     ok: existsSync3(agentPath),
-    message: existsSync3(agentPath) ? agentPath : "Non trovato",
-    fix: !existsSync3(agentPath) ? "Esegui: kiro-memory install" : void 0
+    message: existsSync3(agentPath) ? agentPath : "Not found",
+    fix: !existsSync3(agentPath) ? "Run: kiro-memory install" : void 0
   });
   let mcpOk = false;
   if (existsSync3(mcpPath)) {
@@ -1296,15 +1404,15 @@ async function runDoctor() {
     }
   }
   checks.push({
-    name: "MCP server configurato",
+    name: "MCP server configured",
     ok: mcpOk,
-    message: mcpOk ? "contextkit registrato in mcp.json" : "Non configurato",
-    fix: !mcpOk ? "Esegui: kiro-memory install" : void 0
+    message: mcpOk ? "contextkit registered in mcp.json" : "Not configured",
+    fix: !mcpOk ? "Run: kiro-memory install" : void 0
   });
   checks.push({
     name: "Data directory",
     ok: existsSync3(dataDir),
-    message: existsSync3(dataDir) ? dataDir : "Non creata (verr\xE0 creata al primo uso)"
+    message: existsSync3(dataDir) ? dataDir : "Not created (will be created on first use)"
   });
   let workerOk = false;
   try {
@@ -1319,15 +1427,15 @@ async function runDoctor() {
   checks.push({
     name: "Worker service",
     ok: true,
-    // Non bloccante: si avvia automaticamente
-    message: workerOk ? "Attivo su porta 3001" : "Non in esecuzione (si avvia automaticamente con Kiro)"
+    // Non-blocking: starts automatically with Kiro
+    message: workerOk ? "Running on port 3001" : "Not running (starts automatically with Kiro)"
   });
   const { hasErrors } = printChecks(checks);
   if (hasErrors) {
-    console.log("Alcuni check sono falliti. Risolvi i problemi indicati sopra.\n");
+    console.log("Some checks failed. Fix the issues listed above.\n");
     process.exit(1);
   } else {
-    console.log("Tutto OK! Kiro Memory \xE8 pronto.\n");
+    console.log("All good! Kiro Memory is ready.\n");
   }
 }
 async function main() {