kiro-memory 1.1.3 → 1.2.0

package/README.md

@@ -69,7 +69,7 @@ npm run install:kiro
 Kiro Memory works as a **custom agent**. You must start Kiro with the `--agent` flag:
 
 ```bash
-kiro --agent kiro-memory
+kiro-cli --agent kiro-memory
 ```
 
 > **Why?** Kiro Memory uses hooks (`agentSpawn`, `postToolUse`, `userPromptSubmit`, `stop`) to capture context automatically. Hooks are defined inside the agent configuration, so they only run when the `kiro-memory` agent is active.
@@ -78,10 +78,10 @@ To avoid typing the flag every time, add an alias to your shell:
 
 ```bash
 # Bash
-echo 'alias kiro="kiro --agent kiro-memory"' >> ~/.bashrc && source ~/.bashrc
+echo 'alias kiro="kiro-cli --agent kiro-memory"' >> ~/.bashrc && source ~/.bashrc
 
 # Zsh
-echo 'alias kiro="kiro --agent kiro-memory"' >> ~/.zshrc && source ~/.zshrc
+echo 'alias kiro="kiro-cli --agent kiro-memory"' >> ~/.zshrc && source ~/.zshrc
 ```
 
 Once running, the worker auto-starts and the web dashboard is available at `http://localhost:3001`.
@@ -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.3",
+  "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);

package/plugin/dist/hooks/agentSpawn.js

@@ -384,6 +384,22 @@ var init_Search = __esm({
 });
 
 // src/hooks/utils.ts
+import { writeFileSync, mkdirSync, existsSync } from "fs";
+import { join } from "path";
+function debugLog(hookName, label, data) {
+  if ((process.env.KIRO_MEMORY_LOG_LEVEL || "").toUpperCase() !== "DEBUG") return;
+  try {
+    const dataDir = process.env.KIRO_MEMORY_DATA_DIR || join(process.env.HOME || "/tmp", ".kiro-memory");
+    const logDir = join(dataDir, "logs");
+    if (!existsSync(logDir)) mkdirSync(logDir, { recursive: true });
+    const ts = (/* @__PURE__ */ new Date()).toISOString();
+    const line = `[${ts}] [${hookName}] ${label}: ${JSON.stringify(data)}
+`;
+    const logFile = join(logDir, `hooks-${(/* @__PURE__ */ new Date()).toISOString().split("T")[0]}.log`);
+    writeFileSync(logFile, line, { flag: "a" });
+  } catch {
+  }
+}
 async function readStdin() {
   return new Promise((resolve, reject) => {
     let data = "";
@@ -457,10 +473,13 @@ function formatContext(data) {
 async function runHook(name, handler) {
   try {
     const input = await readStdin();
+    debugLog(name, "stdin", input);
     await handler(input);
+    debugLog(name, "completato", { success: true });
     process.exit(0);
   } catch (error) {
-    process.stderr.write(`[contextkit:${name}] Errore: ${error}
+    debugLog(name, "errore", { error: String(error) });
+    process.stderr.write(`[kiro-memory:${name}] Errore: ${error}
 `);
     process.exit(0);
   }
@@ -534,14 +553,14 @@ var BunQueryCompat = class {
 };
 
 // src/shared/paths.ts
-import { join as join2, dirname, basename } from "path";
+import { join as join3, dirname, basename } from "path";
 import { homedir as homedir2 } from "os";
-import { mkdirSync as mkdirSync2 } from "fs";
+import { mkdirSync as mkdirSync3 } from "fs";
 import { fileURLToPath } from "url";
 
 // src/utils/logger.ts
-import { appendFileSync, existsSync, mkdirSync, readFileSync } from "fs";
-import { join } from "path";
+import { appendFileSync, existsSync as existsSync2, mkdirSync as mkdirSync2, readFileSync } from "fs";
+import { join as join2 } from "path";
 import { homedir } from "os";
 var LogLevel = /* @__PURE__ */ ((LogLevel2) => {
   LogLevel2[LogLevel2["DEBUG"] = 0] = "DEBUG";
@@ -551,7 +570,7 @@ var LogLevel = /* @__PURE__ */ ((LogLevel2) => {
   LogLevel2[LogLevel2["SILENT"] = 4] = "SILENT";
   return LogLevel2;
 })(LogLevel || {});
-var DEFAULT_DATA_DIR = join(homedir(), ".contextkit");
+var DEFAULT_DATA_DIR = join2(homedir(), ".contextkit");
 var Logger = class {
   level = null;
   useColor;
@@ -567,12 +586,12 @@ var Logger = class {
     if (this.logFileInitialized) return;
     this.logFileInitialized = true;
     try {
-      const logsDir = join(DEFAULT_DATA_DIR, "logs");
-      if (!existsSync(logsDir)) {
-        mkdirSync(logsDir, { recursive: true });
+      const logsDir = join2(DEFAULT_DATA_DIR, "logs");
+      if (!existsSync2(logsDir)) {
+        mkdirSync2(logsDir, { recursive: true });
       }
       const date = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
-      this.logFilePath = join(logsDir, `contextkit-${date}.log`);
+      this.logFilePath = join2(logsDir, `contextkit-${date}.log`);
     } catch (error) {
       console.error("[LOGGER] Failed to initialize log file:", error);
       this.logFilePath = null;
@@ -584,8 +603,8 @@ var Logger = class {
   getLevel() {
     if (this.level === null) {
       try {
-        const settingsPath = join(DEFAULT_DATA_DIR, "settings.json");
-        if (existsSync(settingsPath)) {
+        const settingsPath = join2(DEFAULT_DATA_DIR, "settings.json");
+        if (existsSync2(settingsPath)) {
           const settingsData = readFileSync(settingsPath, "utf-8");
           const settings = JSON.parse(settingsData);
           const envLevel = (settings.CONTEXTKIT_LOG_LEVEL || "INFO").toUpperCase();
@@ -766,22 +785,22 @@ function getDirname() {
   return dirname(fileURLToPath(import.meta.url));
 }
 var _dirname = getDirname();
-var DATA_DIR = process.env.CONTEXTKIT_DATA_DIR || join2(homedir2(), ".contextkit");
-var KIRO_CONFIG_DIR = process.env.KIRO_CONFIG_DIR || join2(homedir2(), ".kiro");
-var PLUGIN_ROOT = join2(KIRO_CONFIG_DIR, "plugins", "contextkit");
-var ARCHIVES_DIR = join2(DATA_DIR, "archives");
-var LOGS_DIR = join2(DATA_DIR, "logs");
-var TRASH_DIR = join2(DATA_DIR, "trash");
-var BACKUPS_DIR = join2(DATA_DIR, "backups");
-var MODES_DIR = join2(DATA_DIR, "modes");
-var USER_SETTINGS_PATH = join2(DATA_DIR, "settings.json");
-var DB_PATH = join2(DATA_DIR, "contextkit.db");
-var VECTOR_DB_DIR = join2(DATA_DIR, "vector-db");
-var OBSERVER_SESSIONS_DIR = join2(DATA_DIR, "observer-sessions");
-var KIRO_SETTINGS_PATH = join2(KIRO_CONFIG_DIR, "settings.json");
-var KIRO_CONTEXT_PATH = join2(KIRO_CONFIG_DIR, "context.md");
+var DATA_DIR = process.env.CONTEXTKIT_DATA_DIR || join3(homedir2(), ".contextkit");
+var KIRO_CONFIG_DIR = process.env.KIRO_CONFIG_DIR || join3(homedir2(), ".kiro");
+var PLUGIN_ROOT = join3(KIRO_CONFIG_DIR, "plugins", "contextkit");
+var ARCHIVES_DIR = join3(DATA_DIR, "archives");
+var LOGS_DIR = join3(DATA_DIR, "logs");
+var TRASH_DIR = join3(DATA_DIR, "trash");
+var BACKUPS_DIR = join3(DATA_DIR, "backups");
+var MODES_DIR = join3(DATA_DIR, "modes");
+var USER_SETTINGS_PATH = join3(DATA_DIR, "settings.json");
+var DB_PATH = join3(DATA_DIR, "contextkit.db");
+var VECTOR_DB_DIR = join3(DATA_DIR, "vector-db");
+var OBSERVER_SESSIONS_DIR = join3(DATA_DIR, "observer-sessions");
+var KIRO_SETTINGS_PATH = join3(KIRO_CONFIG_DIR, "settings.json");
+var KIRO_CONTEXT_PATH = join3(KIRO_CONFIG_DIR, "context.md");
 function ensureDir(dirPath) {
-  mkdirSync2(dirPath, { recursive: true });
+  mkdirSync3(dirPath, { recursive: true });
 }
 
 // src/services/sqlite/Database.ts
@@ -1165,7 +1184,7 @@ function createContextKit(config) {
 
 // src/hooks/agentSpawn.ts
 import { spawn } from "child_process";
-import { dirname as dirname2, join as join3 } from "path";
+import { dirname as dirname2, join as join4 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 var __filename_hook = fileURLToPath2(import.meta.url);
 var __dirname_hook = dirname2(__filename_hook);
@@ -1181,7 +1200,7 @@ async function ensureWorkerRunning() {
     if (resp.ok) return;
   } catch {
   }
-  const workerPath = join3(__dirname_hook, "..", "worker-service.js");
+  const workerPath = join4(__dirname_hook, "..", "worker-service.js");
   const child = spawn("node", [workerPath], {
     detached: true,
     stdio: "ignore",

package/plugin/dist/hooks/postToolUse.js

@@ -384,6 +384,22 @@ var init_Search = __esm({
 });
 
 // src/hooks/utils.ts
+import { writeFileSync, mkdirSync, existsSync } from "fs";
+import { join } from "path";
+function debugLog(hookName, label, data) {
+  if ((process.env.KIRO_MEMORY_LOG_LEVEL || "").toUpperCase() !== "DEBUG") return;
+  try {
+    const dataDir = process.env.KIRO_MEMORY_DATA_DIR || join(process.env.HOME || "/tmp", ".kiro-memory");
+    const logDir = join(dataDir, "logs");
+    if (!existsSync(logDir)) mkdirSync(logDir, { recursive: true });
+    const ts = (/* @__PURE__ */ new Date()).toISOString();
+    const line = `[${ts}] [${hookName}] ${label}: ${JSON.stringify(data)}
+`;
+    const logFile = join(logDir, `hooks-${(/* @__PURE__ */ new Date()).toISOString().split("T")[0]}.log`);
+    writeFileSync(logFile, line, { flag: "a" });
+  } catch {
+  }
+}
 async function readStdin() {
   return new Promise((resolve, reject) => {
     let data = "";
@@ -448,10 +464,13 @@ async function notifyWorker(event, data) {
 async function runHook(name, handler) {
   try {
     const input = await readStdin();
+    debugLog(name, "stdin", input);
     await handler(input);
+    debugLog(name, "completato", { success: true });
     process.exit(0);
   } catch (error) {
-    process.stderr.write(`[contextkit:${name}] Errore: ${error}
+    debugLog(name, "errore", { error: String(error) });
+    process.stderr.write(`[kiro-memory:${name}] Errore: ${error}
 `);
     process.exit(0);
   }
@@ -525,14 +544,14 @@ var BunQueryCompat = class {
 };
 
 // src/shared/paths.ts
-import { join as join2, dirname, basename } from "path";
+import { join as join3, dirname, basename } from "path";
 import { homedir as homedir2 } from "os";
-import { mkdirSync as mkdirSync2 } from "fs";
+import { mkdirSync as mkdirSync3 } from "fs";
 import { fileURLToPath } from "url";
 
 // src/utils/logger.ts
-import { appendFileSync, existsSync, mkdirSync, readFileSync } from "fs";
-import { join } from "path";
+import { appendFileSync, existsSync as existsSync2, mkdirSync as mkdirSync2, readFileSync } from "fs";
+import { join as join2 } from "path";
 import { homedir } from "os";
 var LogLevel = /* @__PURE__ */ ((LogLevel2) => {
   LogLevel2[LogLevel2["DEBUG"] = 0] = "DEBUG";
@@ -542,7 +561,7 @@ var LogLevel = /* @__PURE__ */ ((LogLevel2) => {
   LogLevel2[LogLevel2["SILENT"] = 4] = "SILENT";
   return LogLevel2;
 })(LogLevel || {});
-var DEFAULT_DATA_DIR = join(homedir(), ".contextkit");
+var DEFAULT_DATA_DIR = join2(homedir(), ".contextkit");
 var Logger = class {
   level = null;
   useColor;
@@ -558,12 +577,12 @@ var Logger = class {
     if (this.logFileInitialized) return;
     this.logFileInitialized = true;
     try {
-      const logsDir = join(DEFAULT_DATA_DIR, "logs");
-      if (!existsSync(logsDir)) {
-        mkdirSync(logsDir, { recursive: true });
+      const logsDir = join2(DEFAULT_DATA_DIR, "logs");
+      if (!existsSync2(logsDir)) {
+        mkdirSync2(logsDir, { recursive: true });
       }
       const date = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
-      this.logFilePath = join(logsDir, `contextkit-${date}.log`);
+      this.logFilePath = join2(logsDir, `contextkit-${date}.log`);
     } catch (error) {
       console.error("[LOGGER] Failed to initialize log file:", error);
       this.logFilePath = null;
@@ -575,8 +594,8 @@ var Logger = class {
   getLevel() {
     if (this.level === null) {
       try {
-        const settingsPath = join(DEFAULT_DATA_DIR, "settings.json");
-        if (existsSync(settingsPath)) {
+        const settingsPath = join2(DEFAULT_DATA_DIR, "settings.json");
+        if (existsSync2(settingsPath)) {
           const settingsData = readFileSync(settingsPath, "utf-8");
           const settings = JSON.parse(settingsData);
           const envLevel = (settings.CONTEXTKIT_LOG_LEVEL || "INFO").toUpperCase();
@@ -757,22 +776,22 @@ function getDirname() {
   return dirname(fileURLToPath(import.meta.url));
 }
 var _dirname = getDirname();
-var DATA_DIR = process.env.CONTEXTKIT_DATA_DIR || join2(homedir2(), ".contextkit");
-var KIRO_CONFIG_DIR = process.env.KIRO_CONFIG_DIR || join2(homedir2(), ".kiro");
-var PLUGIN_ROOT = join2(KIRO_CONFIG_DIR, "plugins", "contextkit");
-var ARCHIVES_DIR = join2(DATA_DIR, "archives");
-var LOGS_DIR = join2(DATA_DIR, "logs");
-var TRASH_DIR = join2(DATA_DIR, "trash");
-var BACKUPS_DIR = join2(DATA_DIR, "backups");
-var MODES_DIR = join2(DATA_DIR, "modes");
-var USER_SETTINGS_PATH = join2(DATA_DIR, "settings.json");
-var DB_PATH = join2(DATA_DIR, "contextkit.db");
-var VECTOR_DB_DIR = join2(DATA_DIR, "vector-db");
-var OBSERVER_SESSIONS_DIR = join2(DATA_DIR, "observer-sessions");
-var KIRO_SETTINGS_PATH = join2(KIRO_CONFIG_DIR, "settings.json");
-var KIRO_CONTEXT_PATH = join2(KIRO_CONFIG_DIR, "context.md");
+var DATA_DIR = process.env.CONTEXTKIT_DATA_DIR || join3(homedir2(), ".contextkit");
+var KIRO_CONFIG_DIR = process.env.KIRO_CONFIG_DIR || join3(homedir2(), ".kiro");
+var PLUGIN_ROOT = join3(KIRO_CONFIG_DIR, "plugins", "contextkit");
+var ARCHIVES_DIR = join3(DATA_DIR, "archives");
+var LOGS_DIR = join3(DATA_DIR, "logs");
+var TRASH_DIR = join3(DATA_DIR, "trash");
+var BACKUPS_DIR = join3(DATA_DIR, "backups");
+var MODES_DIR = join3(DATA_DIR, "modes");
+var USER_SETTINGS_PATH = join3(DATA_DIR, "settings.json");
+var DB_PATH = join3(DATA_DIR, "contextkit.db");
+var VECTOR_DB_DIR = join3(DATA_DIR, "vector-db");
+var OBSERVER_SESSIONS_DIR = join3(DATA_DIR, "observer-sessions");
+var KIRO_SETTINGS_PATH = join3(KIRO_CONFIG_DIR, "settings.json");
+var KIRO_CONTEXT_PATH = join3(KIRO_CONFIG_DIR, "context.md");
 function ensureDir(dirPath) {
-  mkdirSync2(dirPath, { recursive: true });
+  mkdirSync3(dirPath, { recursive: true });
 }
 
 // src/services/sqlite/Database.ts
@@ -1157,8 +1176,28 @@ function createContextKit(config) {
 // src/hooks/postToolUse.ts
 runHook("postToolUse", async (input) => {
   if (!input.tool_name) return;
-  const ignoredTools = ["glob", "grep", "fs_read", "read", "introspect", "thinking", "todo"];
+  const ignoredTools = ["introspect", "thinking", "todo"];
   if (ignoredTools.includes(input.tool_name)) return;
+  const readOnlyTools = ["glob", "grep", "fs_read", "read"];
+  if (readOnlyTools.includes(input.tool_name)) {
+    const project2 = detectProject(input.cwd);
+    const sdk2 = createContextKit({ project: project2 });
+    try {
+      const files = extractFiles(input.tool_input, input.tool_response);
+      const query = input.tool_input?.pattern || input.tool_input?.regex || input.tool_input?.query || "";
+      const title = input.tool_name === "grep" || input.tool_name === "glob" ? `Cercato: ${query}`.substring(0, 100) : `Letto: ${files[0] || input.tool_input?.path || input.tool_input?.file_path || "file"}`;
+      await sdk2.storeObservation({
+        type: "file-read",
+        title,
+        content: files.length > 0 ? `File: ${files.join(", ")}` : `Tool ${input.tool_name} eseguito`,
+        files
+      });
+      await notifyWorker("observation-created", { project: project2, title, type: "file-read" });
+    } finally {
+      sdk2.close();
+    }
+    return;
+  }
   const project = detectProject(input.cwd);
   const sdk = createContextKit({ project });
   try {
@@ -1214,6 +1253,10 @@ function categorizeToolUse(toolName) {
   const categories = {
     "fs_write": "file-write",
     "write": "file-write",
+    "fs_read": "file-read",
+    "read": "file-read",
+    "glob": "file-read",
+    "grep": "file-read",
     "execute_bash": "command",
     "shell": "command",
     "web_search": "research",

package/plugin/dist/hooks/stop.js

@@ -384,6 +384,22 @@ var init_Search = __esm({
 });
 
 // src/hooks/utils.ts
+import { writeFileSync, mkdirSync, existsSync } from "fs";
+import { join } from "path";
+function debugLog(hookName, label, data) {
+  if ((process.env.KIRO_MEMORY_LOG_LEVEL || "").toUpperCase() !== "DEBUG") return;
+  try {
+    const dataDir = process.env.KIRO_MEMORY_DATA_DIR || join(process.env.HOME || "/tmp", ".kiro-memory");
+    const logDir = join(dataDir, "logs");
+    if (!existsSync(logDir)) mkdirSync(logDir, { recursive: true });
+    const ts = (/* @__PURE__ */ new Date()).toISOString();
+    const line = `[${ts}] [${hookName}] ${label}: ${JSON.stringify(data)}
+`;
+    const logFile = join(logDir, `hooks-${(/* @__PURE__ */ new Date()).toISOString().split("T")[0]}.log`);
+    writeFileSync(logFile, line, { flag: "a" });
+  } catch {
+  }
+}
 async function readStdin() {
   return new Promise((resolve, reject) => {
     let data = "";
@@ -448,10 +464,13 @@ async function notifyWorker(event, data) {
 async function runHook(name, handler) {
   try {
     const input = await readStdin();
+    debugLog(name, "stdin", input);
     await handler(input);
+    debugLog(name, "completato", { success: true });
     process.exit(0);
   } catch (error) {
-    process.stderr.write(`[contextkit:${name}] Errore: ${error}
+    debugLog(name, "errore", { error: String(error) });
+    process.stderr.write(`[kiro-memory:${name}] Errore: ${error}
 `);
     process.exit(0);
   }
@@ -525,14 +544,14 @@ var BunQueryCompat = class {
 };
 
 // src/shared/paths.ts
-import { join as join2, dirname, basename } from "path";
+import { join as join3, dirname, basename } from "path";
 import { homedir as homedir2 } from "os";
-import { mkdirSync as mkdirSync2 } from "fs";
+import { mkdirSync as mkdirSync3 } from "fs";
 import { fileURLToPath } from "url";
 
 // src/utils/logger.ts
-import { appendFileSync, existsSync, mkdirSync, readFileSync } from "fs";
-import { join } from "path";
+import { appendFileSync, existsSync as existsSync2, mkdirSync as mkdirSync2, readFileSync } from "fs";
+import { join as join2 } from "path";
 import { homedir } from "os";
 var LogLevel = /* @__PURE__ */ ((LogLevel2) => {
   LogLevel2[LogLevel2["DEBUG"] = 0] = "DEBUG";
@@ -542,7 +561,7 @@ var LogLevel = /* @__PURE__ */ ((LogLevel2) => {
   LogLevel2[LogLevel2["SILENT"] = 4] = "SILENT";
   return LogLevel2;
 })(LogLevel || {});
-var DEFAULT_DATA_DIR = join(homedir(), ".contextkit");
+var DEFAULT_DATA_DIR = join2(homedir(), ".contextkit");
 var Logger = class {
   level = null;
   useColor;
@@ -558,12 +577,12 @@ var Logger = class {
     if (this.logFileInitialized) return;
     this.logFileInitialized = true;
     try {
-      const logsDir = join(DEFAULT_DATA_DIR, "logs");
-      if (!existsSync(logsDir)) {
-        mkdirSync(logsDir, { recursive: true });
+      const logsDir = join2(DEFAULT_DATA_DIR, "logs");
+      if (!existsSync2(logsDir)) {
+        mkdirSync2(logsDir, { recursive: true });
       }
       const date = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
-      this.logFilePath = join(logsDir, `contextkit-${date}.log`);
+      this.logFilePath = join2(logsDir, `contextkit-${date}.log`);
     } catch (error) {
       console.error("[LOGGER] Failed to initialize log file:", error);
       this.logFilePath = null;
@@ -575,8 +594,8 @@ var Logger = class {
   getLevel() {
     if (this.level === null) {
       try {
-        const settingsPath = join(DEFAULT_DATA_DIR, "settings.json");
-        if (existsSync(settingsPath)) {
+        const settingsPath = join2(DEFAULT_DATA_DIR, "settings.json");
+        if (existsSync2(settingsPath)) {
           const settingsData = readFileSync(settingsPath, "utf-8");
           const settings = JSON.parse(settingsData);
           const envLevel = (settings.CONTEXTKIT_LOG_LEVEL || "INFO").toUpperCase();
@@ -757,22 +776,22 @@ function getDirname() {
   return dirname(fileURLToPath(import.meta.url));
 }
 var _dirname = getDirname();
-var DATA_DIR = process.env.CONTEXTKIT_DATA_DIR || join2(homedir2(), ".contextkit");
-var KIRO_CONFIG_DIR = process.env.KIRO_CONFIG_DIR || join2(homedir2(), ".kiro");
-var PLUGIN_ROOT = join2(KIRO_CONFIG_DIR, "plugins", "contextkit");
-var ARCHIVES_DIR = join2(DATA_DIR, "archives");
-var LOGS_DIR = join2(DATA_DIR, "logs");
-var TRASH_DIR = join2(DATA_DIR, "trash");
-var BACKUPS_DIR = join2(DATA_DIR, "backups");
-var MODES_DIR = join2(DATA_DIR, "modes");
-var USER_SETTINGS_PATH = join2(DATA_DIR, "settings.json");
-var DB_PATH = join2(DATA_DIR, "contextkit.db");
-var VECTOR_DB_DIR = join2(DATA_DIR, "vector-db");
-var OBSERVER_SESSIONS_DIR = join2(DATA_DIR, "observer-sessions");
-var KIRO_SETTINGS_PATH = join2(KIRO_CONFIG_DIR, "settings.json");
-var KIRO_CONTEXT_PATH = join2(KIRO_CONFIG_DIR, "context.md");
+var DATA_DIR = process.env.CONTEXTKIT_DATA_DIR || join3(homedir2(), ".contextkit");
+var KIRO_CONFIG_DIR = process.env.KIRO_CONFIG_DIR || join3(homedir2(), ".kiro");
+var PLUGIN_ROOT = join3(KIRO_CONFIG_DIR, "plugins", "contextkit");
+var ARCHIVES_DIR = join3(DATA_DIR, "archives");
+var LOGS_DIR = join3(DATA_DIR, "logs");
+var TRASH_DIR = join3(DATA_DIR, "trash");
+var BACKUPS_DIR = join3(DATA_DIR, "backups");
+var MODES_DIR = join3(DATA_DIR, "modes");
+var USER_SETTINGS_PATH = join3(DATA_DIR, "settings.json");
+var DB_PATH = join3(DATA_DIR, "contextkit.db");
+var VECTOR_DB_DIR = join3(DATA_DIR, "vector-db");
+var OBSERVER_SESSIONS_DIR = join3(DATA_DIR, "observer-sessions");
+var KIRO_SETTINGS_PATH = join3(KIRO_CONFIG_DIR, "settings.json");
+var KIRO_CONTEXT_PATH = join3(KIRO_CONFIG_DIR, "context.md");
 function ensureDir(dirPath) {
-  mkdirSync2(dirPath, { recursive: true });
+  mkdirSync3(dirPath, { recursive: true });
 }
 
 // src/services/sqlite/Database.ts

package/plugin/dist/hooks/userPromptSubmit.js

@@ -384,6 +384,22 @@ var init_Search = __esm({
 });
 
 // src/hooks/utils.ts
+import { writeFileSync, mkdirSync, existsSync } from "fs";
+import { join } from "path";
+function debugLog(hookName, label, data) {
+  if ((process.env.KIRO_MEMORY_LOG_LEVEL || "").toUpperCase() !== "DEBUG") return;
+  try {
+    const dataDir = process.env.KIRO_MEMORY_DATA_DIR || join(process.env.HOME || "/tmp", ".kiro-memory");
+    const logDir = join(dataDir, "logs");
+    if (!existsSync(logDir)) mkdirSync(logDir, { recursive: true });
+    const ts = (/* @__PURE__ */ new Date()).toISOString();
+    const line = `[${ts}] [${hookName}] ${label}: ${JSON.stringify(data)}
+`;
+    const logFile = join(logDir, `hooks-${(/* @__PURE__ */ new Date()).toISOString().split("T")[0]}.log`);
+    writeFileSync(logFile, line, { flag: "a" });
+  } catch {
+  }
+}
 async function readStdin() {
   return new Promise((resolve, reject) => {
     let data = "";
@@ -448,10 +464,13 @@ async function notifyWorker(event, data) {
 async function runHook(name, handler) {
   try {
     const input = await readStdin();
+    debugLog(name, "stdin", input);
     await handler(input);
+    debugLog(name, "completato", { success: true });
     process.exit(0);
   } catch (error) {
-    process.stderr.write(`[contextkit:${name}] Errore: ${error}
+    debugLog(name, "errore", { error: String(error) });
+    process.stderr.write(`[kiro-memory:${name}] Errore: ${error}
 `);
     process.exit(0);
   }
@@ -525,14 +544,14 @@ var BunQueryCompat = class {
 };
 
 // src/shared/paths.ts
-import { join as join2, dirname, basename } from "path";
+import { join as join3, dirname, basename } from "path";
 import { homedir as homedir2 } from "os";
-import { mkdirSync as mkdirSync2 } from "fs";
+import { mkdirSync as mkdirSync3 } from "fs";
 import { fileURLToPath } from "url";
 
 // src/utils/logger.ts
-import { appendFileSync, existsSync, mkdirSync, readFileSync } from "fs";
-import { join } from "path";
+import { appendFileSync, existsSync as existsSync2, mkdirSync as mkdirSync2, readFileSync } from "fs";
+import { join as join2 } from "path";
 import { homedir } from "os";
 var LogLevel = /* @__PURE__ */ ((LogLevel2) => {
   LogLevel2[LogLevel2["DEBUG"] = 0] = "DEBUG";
@@ -542,7 +561,7 @@ var LogLevel = /* @__PURE__ */ ((LogLevel2) => {
   LogLevel2[LogLevel2["SILENT"] = 4] = "SILENT";
   return LogLevel2;
 })(LogLevel || {});
-var DEFAULT_DATA_DIR = join(homedir(), ".contextkit");
+var DEFAULT_DATA_DIR = join2(homedir(), ".contextkit");
 var Logger = class {
   level = null;
   useColor;
@@ -558,12 +577,12 @@ var Logger = class {
     if (this.logFileInitialized) return;
     this.logFileInitialized = true;
     try {
-      const logsDir = join(DEFAULT_DATA_DIR, "logs");
-      if (!existsSync(logsDir)) {
-        mkdirSync(logsDir, { recursive: true });
+      const logsDir = join2(DEFAULT_DATA_DIR, "logs");
+      if (!existsSync2(logsDir)) {
+        mkdirSync2(logsDir, { recursive: true });
       }
       const date = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
-      this.logFilePath = join(logsDir, `contextkit-${date}.log`);
+      this.logFilePath = join2(logsDir, `contextkit-${date}.log`);
     } catch (error) {
       console.error("[LOGGER] Failed to initialize log file:", error);
       this.logFilePath = null;
@@ -575,8 +594,8 @@ var Logger = class {
   getLevel() {
     if (this.level === null) {
       try {
-        const settingsPath = join(DEFAULT_DATA_DIR, "settings.json");
-        if (existsSync(settingsPath)) {
+        const settingsPath = join2(DEFAULT_DATA_DIR, "settings.json");
+        if (existsSync2(settingsPath)) {
           const settingsData = readFileSync(settingsPath, "utf-8");
           const settings = JSON.parse(settingsData);
           const envLevel = (settings.CONTEXTKIT_LOG_LEVEL || "INFO").toUpperCase();
@@ -757,22 +776,22 @@ function getDirname() {
   return dirname(fileURLToPath(import.meta.url));
 }
 var _dirname = getDirname();
-var DATA_DIR = process.env.CONTEXTKIT_DATA_DIR || join2(homedir2(), ".contextkit");
-var KIRO_CONFIG_DIR = process.env.KIRO_CONFIG_DIR || join2(homedir2(), ".kiro");
-var PLUGIN_ROOT = join2(KIRO_CONFIG_DIR, "plugins", "contextkit");
-var ARCHIVES_DIR = join2(DATA_DIR, "archives");
-var LOGS_DIR = join2(DATA_DIR, "logs");
-var TRASH_DIR = join2(DATA_DIR, "trash");
-var BACKUPS_DIR = join2(DATA_DIR, "backups");
-var MODES_DIR = join2(DATA_DIR, "modes");
-var USER_SETTINGS_PATH = join2(DATA_DIR, "settings.json");
-var DB_PATH = join2(DATA_DIR, "contextkit.db");
-var VECTOR_DB_DIR = join2(DATA_DIR, "vector-db");
-var OBSERVER_SESSIONS_DIR = join2(DATA_DIR, "observer-sessions");
-var KIRO_SETTINGS_PATH = join2(KIRO_CONFIG_DIR, "settings.json");
-var KIRO_CONTEXT_PATH = join2(KIRO_CONFIG_DIR, "context.md");
+var DATA_DIR = process.env.CONTEXTKIT_DATA_DIR || join3(homedir2(), ".contextkit");
+var KIRO_CONFIG_DIR = process.env.KIRO_CONFIG_DIR || join3(homedir2(), ".kiro");
+var PLUGIN_ROOT = join3(KIRO_CONFIG_DIR, "plugins", "contextkit");
+var ARCHIVES_DIR = join3(DATA_DIR, "archives");
+var LOGS_DIR = join3(DATA_DIR, "logs");
+var TRASH_DIR = join3(DATA_DIR, "trash");
+var BACKUPS_DIR = join3(DATA_DIR, "backups");
+var MODES_DIR = join3(DATA_DIR, "modes");
+var USER_SETTINGS_PATH = join3(DATA_DIR, "settings.json");
+var DB_PATH = join3(DATA_DIR, "contextkit.db");
+var VECTOR_DB_DIR = join3(DATA_DIR, "vector-db");
+var OBSERVER_SESSIONS_DIR = join3(DATA_DIR, "observer-sessions");
+var KIRO_SETTINGS_PATH = join3(KIRO_CONFIG_DIR, "settings.json");
+var KIRO_CONTEXT_PATH = join3(KIRO_CONFIG_DIR, "context.md");
 function ensureDir(dirPath) {
-  mkdirSync2(dirPath, { recursive: true });
+  mkdirSync3(dirPath, { recursive: true });
 }
 
 // src/services/sqlite/Database.ts
@@ -1156,13 +1175,13 @@ function createContextKit(config) {
 
 // src/hooks/userPromptSubmit.ts
 runHook("userPromptSubmit", async (input) => {
+  const promptText = input.prompt || input.user_prompt || input.tool_input?.prompt || input.tool_input?.content;
+  if (!promptText || typeof promptText !== "string" || promptText.trim().length === 0) return;
   const project = detectProject(input.cwd);
   const sdk = createContextKit({ project });
   try {
-    const promptText = input.tool_input?.prompt || input.tool_input?.content || input.tool_input?.message || JSON.stringify(input.tool_input || "").substring(0, 500);
-    if (!promptText || promptText === '""') return;
-    const sessionId = `kiro-${(/* @__PURE__ */ new Date()).toISOString().split("T")[0]}-${project}`;
-    await sdk.storePrompt(sessionId, Date.now(), promptText);
+    const sessionId = input.session_id || `kiro-${(/* @__PURE__ */ new Date()).toISOString().split("T")[0]}-${project}`;
+    await sdk.storePrompt(sessionId, Date.now(), promptText.trim());
     await notifyWorker("prompt-created", { project });
   } finally {
     sdk.close();

package/plugin/dist/index.js

@@ -1202,6 +1202,22 @@ function createContextKit(config) {
 init_Search();
 
 // src/hooks/utils.ts
+import { writeFileSync, mkdirSync as mkdirSync3, existsSync as existsSync3 } from "fs";
+import { join as join3 } from "path";
+function debugLog(hookName, label, data) {
+  if ((process.env.KIRO_MEMORY_LOG_LEVEL || "").toUpperCase() !== "DEBUG") return;
+  try {
+    const dataDir = process.env.KIRO_MEMORY_DATA_DIR || join3(process.env.HOME || "/tmp", ".kiro-memory");
+    const logDir = join3(dataDir, "logs");
+    if (!existsSync3(logDir)) mkdirSync3(logDir, { recursive: true });
+    const ts = (/* @__PURE__ */ new Date()).toISOString();
+    const line = `[${ts}] [${hookName}] ${label}: ${JSON.stringify(data)}
+`;
+    const logFile = join3(logDir, `hooks-${(/* @__PURE__ */ new Date()).toISOString().split("T")[0]}.log`);
+    writeFileSync(logFile, line, { flag: "a" });
+  } catch {
+  }
+}
 async function readStdin() {
   return new Promise((resolve, reject) => {
     let data = "";
@@ -1275,10 +1291,13 @@ function formatContext(data) {
 async function runHook(name, handler) {
   try {
     const input = await readStdin();
+    debugLog(name, "stdin", input);
     await handler(input);
+    debugLog(name, "completato", { success: true });
     process.exit(0);
   } catch (error) {
-    process.stderr.write(`[contextkit:${name}] Errore: ${error}
+    debugLog(name, "errore", { error: String(error) });
+    process.stderr.write(`[kiro-memory:${name}] Errore: ${error}
 `);
     process.exit(0);
   }

package/plugin/dist/viewer.html

@@ -32,6 +32,8 @@
       --pink-muted: rgba(244, 114, 182, 0.15);
       --red: #f87171;
       --red-muted: rgba(248, 113, 113, 0.15);
+      --teal: #2dd4bf;
+      --teal-muted: rgba(45, 212, 191, 0.15);
       --sidebar-width: 260px;
       --header-height: 56px;
       --radius: 8px;
@@ -415,6 +417,7 @@
     .card--summary { border-left-color: var(--violet); }
     .card--prompt { border-left-color: var(--pink); }
     .card--delegation { border-left-color: var(--accent); }
+    .card--file-read { border-left-color: var(--teal); }
     .card--tool-use { border-left-color: var(--text-muted); }
     .card--default { border-left-color: var(--text-muted); }
 
@@ -445,6 +448,7 @@
     .badge--summary { background: var(--violet-muted); color: var(--violet); }
     .badge--prompt { background: var(--pink-muted); color: var(--pink); }
     .badge--delegation { background: var(--accent-muted); color: var(--accent); }
+    .badge--file-read { background: var(--teal-muted); color: var(--teal); }
     .badge--tool-use { background: var(--bg-tertiary); color: var(--text-secondary); }
     .badge--default { background: var(--bg-tertiary); color: var(--text-secondary); }
 

package/plugin/dist/viewer.js

@@ -23597,6 +23597,7 @@ var import_react = __toESM(require_react(), 1);
 function getBadgeClass(type) {
   const map = {
     "file-write": "badge--file-write",
+    "file-read": "badge--file-read",
     "command": "badge--command",
     "research": "badge--research",
     "delegation": "badge--delegation",