kiro-memory 1.1.4 → 1.2.0

package/README.md

@@ -308,6 +308,105 @@ npm run test:context
 npm run test:server
 ```
 
+## Troubleshooting
+
+### `invalid ELF header` (WSL)
+
+```
+Error: .../better_sqlite3.node: invalid ELF header
+```
+
+This happens when the native module was compiled for Windows but you're running inside WSL (Linux). Common cause: npm installed to the Windows filesystem (`/mnt/c/...`) instead of the Linux one.
+
+**Fix:**
+
+```bash
+# Check which node you're using
+which node
+# If it shows /mnt/c/... you're using Windows Node inside WSL
+
+# Install Node.js natively in WSL
+curl -fsSL https://deb.nodesource.com/setup_22.x | sudo -E bash -
+sudo apt-get install -y nodejs
+
+# Or use nvm (recommended)
+curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.40.1/install.sh | bash
+nvm install 22
+
+# Verify
+which node  # Should be /home/... or /root/.nvm/...
+
+# Reinstall
+npm install -g kiro-memory
+```
+
+### `npm prefix` pointing to Windows (WSL)
+
+If `npm prefix -g` returns a `/mnt/c/...` path, npm installs global packages on the Windows filesystem, causing native module issues.
+
+**Fix:**
+
+```bash
+mkdir -p ~/.npm-global
+npm config set prefix ~/.npm-global
+echo 'export PATH="$HOME/.npm-global/bin:$PATH"' >> ~/.bashrc
+source ~/.bashrc
+
+# Reinstall
+npm install -g kiro-memory
+```
+
+### Missing build tools (Linux/WSL)
+
+```
+gyp ERR! find Python
+gyp ERR! stack Error: Could not find any Python installation to use
+```
+
+Native modules like `better-sqlite3` need compilation tools.
+
+**Fix:**
+
+```bash
+sudo apt-get update && sudo apt-get install -y build-essential python3
+npm install -g kiro-memory --build-from-source
+```
+
+### `no agent with name kiro-memory found`
+
+The agent configuration was not installed. Run the install command:
+
+```bash
+kiro-memory install
+```
+
+This creates the agent config at `~/.kiro/agents/contextkit.json`. Note: the agent name is `contextkit-memory`, so start Kiro with:
+
+```bash
+kiro-cli --agent contextkit-memory
+```
+
+### Port 3001 already in use
+
+```bash
+# Find what's using the port
+lsof -i :3001
+
+# Kill the process
+kill -9 <PID>
+
+# Or use a different port
+export KIRO_MEMORY_WORKER_PORT=3002
+```
+
+### Quick diagnostics
+
+Run the built-in doctor command to check your environment:
+
+```bash
+kiro-memory doctor
+```
+
 ## Contributing
 
 Contributions are welcome. Please open an issue to discuss proposed changes before submitting a pull request. See [CONTRIBUTING.md](CONTRIBUTING.md) for guidelines.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kiro-memory",
-  "version": "1.1.4",
+  "version": "1.2.0",
   "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

@@ -900,8 +900,8 @@ var ContextKitSDK = class {
   }
   detectProject() {
     try {
-      const { execSync } = __require("child_process");
-      const gitRoot = execSync("git rev-parse --show-toplevel", {
+      const { execSync: execSync2 } = __require("child_process");
+      const gitRoot = execSync2("git rev-parse --show-toplevel", {
         cwd: process.cwd(),
         encoding: "utf8",
         stdio: ["pipe", "pipe", "ignore"]
@@ -1081,9 +1081,264 @@ 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 { join as join3, dirname as dirname2 } from "path";
+import { homedir as homedir3, platform, release } from "os";
+import { fileURLToPath as fileURLToPath2 } from "url";
 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));
+function isWSL() {
+  try {
+    const rel = release().toLowerCase();
+    if (rel.includes("microsoft") || rel.includes("wsl")) return true;
+    if (existsSync3("/proc/version")) {
+      const proc = readFileSync2("/proc/version", "utf8").toLowerCase();
+      return proc.includes("microsoft") || proc.includes("wsl");
+    }
+    return false;
+  } catch {
+    return false;
+  }
+}
+function commandExists(cmd) {
+  try {
+    execSync(`which ${cmd}`, { stdio: "ignore" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function runEnvironmentChecks() {
+  const checks = [];
+  const wsl = isWSL();
+  const os = platform();
+  checks.push({
+    name: "Sistema operativo",
+    ok: os === "linux" || os === "darwin",
+    message: os === "linux" ? wsl ? "Linux (WSL)" : "Linux" : os === "darwin" ? "macOS" : `${os} (non supportato ufficialmente)`
+  });
+  if (wsl) {
+    const nodePath = process.execPath;
+    const nodeOnWindows = nodePath.startsWith("/mnt/c") || nodePath.startsWith("/mnt/d");
+    checks.push({
+      name: "WSL: Node.js nativo",
+      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
+    });
+    try {
+      const npmPrefix = execSync("npm prefix -g", { encoding: "utf8" }).trim();
+      const prefixOnWindows = npmPrefix.startsWith("/mnt/c") || npmPrefix.startsWith("/mnt/d");
+      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:
+  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
+      });
+    } catch {
+      checks.push({
+        name: "WSL: npm global prefix",
+        ok: false,
+        message: "Impossibile determinare npm prefix"
+      });
+    }
+  }
+  const nodeVersion = parseInt(process.versions.node.split(".")[0]);
+  checks.push({
+    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
+  });
+  let sqliteOk = false;
+  let sqliteMsg = "";
+  try {
+    __require("better-sqlite3");
+    sqliteOk = true;
+    sqliteMsg = "Modulo nativo caricato correttamente";
+  } catch (err) {
+    sqliteMsg = err.code === "ERR_DLOPEN_FAILED" ? "Binario nativo incompatibile (ELF header invalido \u2014 probabile mismatch piattaforma)" : `Errore: ${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
+  });
+  if (os === "linux") {
+    const hasMake = commandExists("make");
+    const hasGcc = commandExists("g++") || commandExists("gcc");
+    const hasPython = commandExists("python3") || commandExists("python");
+    const allPresent = hasMake && hasGcc && hasPython;
+    const missing = [];
+    if (!hasMake || !hasGcc) missing.push("build-essential");
+    if (!hasPython) missing.push("python3");
+    checks.push({
+      name: "Build tools (moduli nativi)",
+      ok: allPresent,
+      message: allPresent ? "make, g++, python3 disponibili" : `Mancanti: ${missing.join(", ")}`,
+      fix: !allPresent ? `Installa i pacchetti richiesti:
+  sudo apt-get update && sudo apt-get install -y ${missing.join(" ")}
+  Poi reinstalla: npm install -g kiro-memory --build-from-source` : void 0
+    });
+  }
+  return checks;
+}
+function printChecks(checks) {
+  let hasErrors = false;
+  console.log("");
+  for (const check of checks) {
+    const icon = check.ok ? "\x1B[32m\u2713\x1B[0m" : "\x1B[31m\u2717\x1B[0m";
+    console.log(`  ${icon} ${check.name}: ${check.message}`);
+    if (!check.ok && check.fix) {
+      console.log(`    \x1B[33m\u2192 Fix:\x1B[0m`);
+      for (const line of check.fix.split("\n")) {
+        console.log(`      ${line}`);
+      }
+    }
+    if (!check.ok) hasErrors = true;
+  }
+  console.log("");
+  return { hasErrors };
+}
+async function installKiro() {
+  console.log("\n=== Kiro Memory - Installazione ===\n");
+  console.log("[1/3] Diagnostica ambiente...");
+  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");
+    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");
+  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 agentDestPath = join3(agentsDir, "contextkit.json");
+  writeFileSync(agentDestPath, agentConfig, "utf8");
+  console.log(`  \u2192 Agent config: ${agentDestPath}`);
+  const mcpFilePath = join3(settingsDir, "mcp.json");
+  let mcpConfig = { mcpServers: {} };
+  if (existsSync3(mcpFilePath)) {
+    try {
+      mcpConfig = JSON.parse(readFileSync2(mcpFilePath, "utf8"));
+      if (!mcpConfig.mcpServers) mcpConfig.mcpServers = {};
+    } catch {
+    }
+  }
+  mcpConfig.mcpServers.contextkit = {
+    command: "node",
+    args: [join3(distDir, "servers", "mcp-server.js")]
+  };
+  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}`);
+  }
+  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
+`);
+}
+async function runDoctor() {
+  console.log("\n=== Kiro Memory - Diagnostica ===");
+  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",
+    ok: existsSync3(agentPath),
+    message: existsSync3(agentPath) ? agentPath : "Non trovato",
+    fix: !existsSync3(agentPath) ? "Esegui: kiro-memory install" : void 0
+  });
+  let mcpOk = false;
+  if (existsSync3(mcpPath)) {
+    try {
+      const mcp = JSON.parse(readFileSync2(mcpPath, "utf8"));
+      mcpOk = !!mcp.mcpServers?.contextkit;
+    } catch {
+    }
+  }
+  checks.push({
+    name: "MCP server configurato",
+    ok: mcpOk,
+    message: mcpOk ? "contextkit registrato in mcp.json" : "Non configurato",
+    fix: !mcpOk ? "Esegui: 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)"
+  });
+  let workerOk = false;
+  try {
+    const port = process.env.KIRO_MEMORY_WORKER_PORT || "3001";
+    execSync(`curl -s -o /dev/null -w "%{http_code}" http://127.0.0.1:${port}/api/health`, {
+      timeout: 2e3,
+      encoding: "utf8"
+    });
+    workerOk = true;
+  } catch {
+  }
+  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)"
+  });
+  const { hasErrors } = printChecks(checks);
+  if (hasErrors) {
+    console.log("Alcuni check sono falliti. Risolvi i problemi indicati sopra.\n");
+    process.exit(1);
+  } else {
+    console.log("Tutto OK! Kiro Memory \xE8 pronto.\n");
+  }
+}
 async function main() {
+  if (command === "install") {
+    await installKiro();
+    return;
+  }
+  if (command === "doctor") {
+    await runDoctor();
+    return;
+  }
   const contextkit = createContextKit();
   try {
     switch (command) {
@@ -1238,7 +1493,11 @@ async function addSummary(contextkit, content) {
 `);
 }
 function showHelp() {
-  console.log(`Usage: contextkit <command> [options]
+  console.log(`Usage: kiro-memory <command> [options]
+
+Setup:
+  install                   Install hooks, MCP server, and agent config into Kiro CLI
+  doctor                    Run environment diagnostics (checks Node, build tools, WSL, etc.)
 
 Commands:
   context, ctx              Show current project context
@@ -1250,10 +1509,11 @@ Commands:
   help                      Show this help message
 
 Examples:
-  contextkit context
-  contextkit search "authentication"
-  contextkit observations 20
-  contextkit add-observation "Bug Fix" "Fixed the login issue"
+  kiro-memory install
+  kiro-memory doctor
+  kiro-memory context
+  kiro-memory search "authentication"
+  kiro-memory observations 20
 `);
 }
 main().catch(console.error);