@krimto-labs/krimto 0.2.19 → 0.2.21

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@krimto-labs/krimto",
-  "version": "0.2.19",
+  "version": "0.2.21",
   "description": "Open-source team memory layer for AI agents — markdown files in git, user/team/org hierarchy, cross-vendor MCP server.",
   "license": "Apache-2.0",
   "type": "module",

package/src/cli/editors.ts

@@ -126,10 +126,12 @@ async function askEditorsList(
       description: current.includes(env.editor)
         ? "currently connected"
         : env.present
-          ? "detected on this machine"
-          : env.mcpWire === null
-            ? "not detected — manual snippet only"
-            : "not detected — toggle on if you want anyway",
+          ? "detected in this project"
+          : env.installed
+            ? "installed on this machine (not in this project yet)"
+            : env.mcpWire === null
+              ? "not detected — manual snippet only"
+              : "not detected — toggle on if you want anyway",
       checked: current.includes(env.editor),
     })),
   });

package/src/cli/init.ts

@@ -106,14 +106,52 @@ export type McpWireMethod =
 
 export interface EditorEnvironment {
   editor: EditorKind;
-  /** True when local signals (file/dir presence) indicate this editor is in use here. */
+  /**
+   * True when local **project-level** signals (file/dir presence inside `cwd`) indicate this
+   * editor is in use *for this project*. Narrow scope — `.cursor/`, `CLAUDE.md`, etc.
+   */
   present: boolean;
+  /**
+   * v0.2.21: True when **machine-level** signals (files/dirs in `homeDir`) indicate this editor
+   * is installed and has been used at least once on this machine. Broader than `present` — catches
+   * the case where a user is editing in Cursor but the project folder hasn't acquired a `.cursor/`
+   * directory yet. The wizard preselects an editor when `present || installed`.
+   */
+  installed: boolean;
   /** Project-relative rules-file path (the CLAUDE.md / .cursor/rules/krimto.mdc / etc.). */
   rulesPath: string;
   /** How to wire MCP config for this editor, or `null` when wiring isn't automated yet. */
   mcpWire: McpWireMethod | null;
 }
 
+/**
+ * v0.2.21: Machine-level installation check. Returns true when this editor's home-dir footprint
+ * suggests it's been installed + run on this machine. Used by `detectEditorEnvironments` to
+ * populate `EditorEnvironment.installed` so the wizard can preselect editors even when the
+ * current project folder has no editor-specific signals yet.
+ *
+ * The home-dir paths checked are well-known per editor: each is created on first launch.
+ *   • Cursor       — `~/.cursor/`
+ *   • Claude Code  — `~/.claude.json` (user config) or `~/.claude/` (project data)
+ *   • Codex        — `~/.codex/`
+ *   • Gemini CLI   — `~/.gemini/`
+ *
+ * False positives (folder exists from a previous uninstalled tool) are harmless: the user can
+ * untoggle. False negatives (editor installed but never launched) are equally rare in practice.
+ */
+async function isInstalledOnMachine(editor: EditorKind, homeDir: string): Promise<boolean> {
+  if (editor === "cursor") return exists(path.join(homeDir, ".cursor"));
+  if (editor === "claude-code") {
+    return (
+      (await exists(path.join(homeDir, ".claude.json"))) ||
+      (await exists(path.join(homeDir, ".claude")))
+    );
+  }
+  if (editor === "codex") return exists(path.join(homeDir, ".codex"));
+  if (editor === "gemini-cli") return exists(path.join(homeDir, ".gemini"));
+  return false;
+}
+
 /**
  * Resolve every editor Krimto can reason about into an `EditorEnvironment` triple
  * (editor + rules-file path + mcp-wiring method). `present` reflects detection signals;
@@ -136,10 +174,18 @@ export async function detectEditorEnvironments(
     (await exists(path.join(cwd, ".gemini")));
   const cursorPresent = await exists(path.join(cwd, ".cursor"));
 
+  // v0.2.21: machine-level installation signals — catch the case where the user is editing in
+  // Cursor (or Claude Code) but the project folder hasn't acquired editor-specific files yet.
+  const cursorInstalled = await isInstalledOnMachine("cursor", homeDir);
+  const claudeInstalled = await isInstalledOnMachine("claude-code", homeDir);
+  const codexInstalled = await isInstalledOnMachine("codex", homeDir);
+  const geminiInstalled = await isInstalledOnMachine("gemini-cli", homeDir);
+
   return [
     {
       editor: "cursor",
       present: cursorPresent,
+      installed: cursorInstalled,
       rulesPath: path.join(".cursor", "rules", "krimto.mdc"),
       mcpWire: {
         method: "json",
@@ -150,6 +196,7 @@ export async function detectEditorEnvironments(
     {
       editor: "claude-code",
       present: claudePresent,
+      installed: claudeInstalled,
       rulesPath: "CLAUDE.md",
       // `claude mcp add krimto ...` is the supported invocation. Shelling out to the editor's
       // own CLI sidesteps the question of which exact file Claude Code persists MCP config in
@@ -163,6 +210,7 @@ export async function detectEditorEnvironments(
     {
       editor: "gemini-cli",
       present: geminiPresent,
+      installed: geminiInstalled,
       rulesPath: "GEMINI.md",
       // Deferred — Gemini CLI's MCP config path needs empirical confirmation before we write
       // to it. v0.2.17 prints a copy-paste snippet instead.
@@ -171,6 +219,7 @@ export async function detectEditorEnvironments(
     {
       editor: "codex",
       present: codexPresent,
+      installed: codexInstalled,
       rulesPath: "AGENTS.md",
       // Deferred — Codex's config is TOML (`~/.codex/config.toml`); writing TOML safely needs
       // a parser we haven't added yet. v0.2.17 prints a copy-paste snippet instead.

package/src/cli/join.ts

@@ -180,11 +180,14 @@ async function askEditors(envs: EditorEnvironment[]): Promise<EditorKind[]> {
       value: env.editor,
       name: EDITOR_LABEL[env.editor],
       description: env.present
-        ? "detected on this machine"
-        : env.mcpWire === null
-          ? "not detected — manual snippet only"
-          : "not detected — toggle on if you want anyway",
-      checked: env.present,
+        ? "detected in this project"
+        : env.installed
+          ? "installed on this machine (not in this project yet)"
+          : env.mcpWire === null
+            ? "not detected — manual snippet only"
+            : "not detected — toggle on if you want anyway",
+      // v0.2.21: preselect on either signal — installed-on-machine still counts.
+      checked: env.present || env.installed,
     })),
   });
 }

package/src/cli/status.ts

@@ -17,6 +17,7 @@ import { promisify } from "node:util";
 
 import { ActivityLog, type ActivityEntry } from "../server/activity";
 import { isProcessAlive, type LockInfo } from "../server/lock";
+import { KRIMTO_VERSION } from "../server/index";
 import {
   detectEditorEnvironments,
   detectExistingSetup,
@@ -174,12 +175,12 @@ function headerLine(
 ): string {
   if (status === "ok") {
     if (lock?.alive) {
-      return `\n✅ Krimto is working · v0.2.17\n   PID ${lock.info.pid} (${lock.info.mode}), started ${humanAgo(lock.info.started, now)}\n`;
+      return `\n✅ Krimto is working · v${KRIMTO_VERSION}\n   PID ${lock.info.pid} (${lock.info.mode}), started ${humanAgo(lock.info.started, now)}\n`;
     }
-    return `\n✅ Krimto is configured · v0.2.17\n   No active server right now — it will be launched on demand by your editor.\n`;
+    return `\n✅ Krimto is configured · v${KRIMTO_VERSION}\n   No active server right now — it will be launched on demand by your editor.\n`;
   }
   if (status === "warning") {
-    return `\n⚠️  Krimto needs attention · v0.2.17\n`;
+    return `\n⚠️  Krimto needs attention · v${KRIMTO_VERSION}\n`;
   }
   return `\n🔴 Krimto isn't set up on this machine\n   Run: $ npx @krimto-labs/krimto init\n`;
 }

package/src/cli/wizard.ts

@@ -24,6 +24,7 @@ import {
   type WizardAnswers,
 } from "./init";
 import { runSetupEmbeddings } from "./setupEmbeddings";
+import { KRIMTO_VERSION } from "../server/index";
 
 const EDITOR_LABEL: Record<EditorKind, string> = {
   cursor: "Cursor",
@@ -149,12 +150,17 @@ async function runFreshWizard(
   io: WizardIO,
   snapshot: SetupSnapshot | null = null,
 ): Promise<ApplyResult | null> {
-  io.out("\nKrimto — Setting up your AI's memory · v0.2.17\n\n");
+  io.out(`\nKrimto — Setting up your AI's memory · v${KRIMTO_VERSION}\n\n`);
   const envs = await detectEditorEnvironments(cwd, opts.homeDir);
   printScan(envs, io);
 
   const selectedEditors = await askEditors(envs, snapshot);
-  const runMode = await askRunMode(snapshot?.runMode);
+  // v0.2.20 — smart default: stdio Krimto can only serve one editor at a time (single-writer
+  // lock on the data dir). When the user picks 2+ editors, recommend "Always running" so they
+  // can all use Krimto simultaneously over HTTP. Snapshot.runMode wins on reconfigure (respects
+  // the user's prior choice). First-run with one editor → "as-needed" (simplest).
+  const smartDefault: RunMode = selectedEditors.length >= 2 ? "always-running" : "as-needed";
+  const runMode = await askRunMode(snapshot?.runMode ?? smartDefault, selectedEditors.length);
   const whoFor = await askWhoFor();
   if (whoFor === "team") {
     io.out("\nGreat — team mode is set up via `krimto team init` (Phase C). Run that next.\n");
@@ -188,33 +194,52 @@ async function askEditors(
       value: env.editor,
       name: EDITOR_LABEL[env.editor],
       description: env.present
-        ? "detected on this machine"
-        : env.mcpWire === null
-          ? "not detected — manual snippet only"
-          : "not detected — toggle on if you want anyway",
+        ? "detected in this project"
+        : env.installed
+          ? "installed on this machine (not in this project yet)"
+          : env.mcpWire === null
+            ? "not detected — manual snippet only"
+            : "not detected — toggle on if you want anyway",
+      // v0.2.21: preselect on either project-level (present) OR machine-level (installed) signal.
       checked: snapshot
         ? snapshot.registeredEditors.includes(env.editor)
-        : env.present,
+        : env.present || env.installed,
     })),
   });
 }
 
-async function askRunMode(defaultMode: RunMode = "as-needed"): Promise<RunMode> {
+async function askRunMode(
+  defaultMode: RunMode = "as-needed",
+  editorCount = 1,
+): Promise<RunMode> {
+  // v0.2.20 — when 2+ editors are selected, "as needed" is broken by Krimto's single-writer
+  // lock: only the first editor to call wins; the others fail. The choice descriptions reflect
+  // this so a user picking "as needed" with multiple editors sees the warning before they commit.
+  const multi = editorCount >= 2;
   return select<RunMode>({
     message: "How should Krimto run?",
     default: defaultMode,
     choices: [
       {
         value: "as-needed",
-        name: "As needed (recommended)",
-        description:
-          "Your editor launches Krimto when it needs it. Simplest setup —\nno background process to manage. Works for solo use on one machine.",
+        name: multi ? "As needed (⚠️  one editor at a time only)" : "As needed (recommended)",
+        description: multi
+          ? `Your editor launches Krimto when it needs it. Simple — but Krimto's single-writer\n` +
+            `lock means only one of your ${editorCount} editors can use it at a time. The second one\n` +
+            `to call will fail until the first one exits. Pick "Always running" instead if you\n` +
+            `want all of them to work simultaneously.`
+          : "Your editor launches Krimto when it needs it. Simplest setup —\nno background process to manage. Works for solo use on one machine.",
       },
       {
         value: "always-running",
-        name: "Always running (background service)",
-        description:
-          "Krimto runs continuously, even after you close your terminal.\nAuto-starts when you log in. Best if multiple editors talk to one Krimto\nor you want /ui always available.",
+        name: multi
+          ? "Always running (recommended for multi-editor)"
+          : "Always running (background service)",
+        description: multi
+          ? `ONE Krimto runs continuously in the background; ALL ${editorCount} of your editors connect\n` +
+            `to it over HTTP. No lock fights — they can all save and recall simultaneously.\n` +
+            `Installs launchd / systemd / schtasks on first use.`
+          : "Krimto runs continuously, even after you close your terminal.\nAuto-starts when you log in. Best if multiple editors talk to one Krimto\nor you want /ui always available.",
       },
       {
         value: "manual",
@@ -296,8 +321,14 @@ async function askSearch(
 function printScan(envs: EditorEnvironment[], io: WizardIO): void {
   io.out("  Scanning your machine ...\n\n");
   for (const env of envs) {
-    const dot = env.present ? "✓" : "–";
-    io.out(`    ${dot} ${EDITOR_LABEL[env.editor].padEnd(14)} ${env.present ? "detected" : "not found"}\n`);
+    // v0.2.21: three states — project-level, machine-level only, not found.
+    const dot = env.present ? "✓" : env.installed ? "~" : "–";
+    const note = env.present
+      ? "detected (in this project)"
+      : env.installed
+        ? "installed (machine-wide)"
+        : "not found";
+    io.out(`    ${dot} ${EDITOR_LABEL[env.editor].padEnd(14)} ${note}\n`);
   }
   io.out("\n");
 }
@@ -396,16 +427,24 @@ export interface NonInteractiveOptions extends ApplyOptions {
 
 /**
  * Skip the prompts entirely and apply with sensible defaults. Used by CI and the `--yes` flag.
- * Defaults: all detected editors, "as-needed" mode, "just-me", keyword search.
+ * Defaults: all detected editors, "just-me", keyword search.
+ *
+ * Run mode is "as-needed" for a single editor, "always-running" when 2+ editors are selected —
+ * mirrors the interactive wizard's smart default (v0.2.20). The stdio + lock combination only
+ * supports one editor at a time, so multi-editor `--yes` users should land on the HTTP-backed
+ * always-running mode by default. Tests that want the old behavior pass `runMode: "as-needed"`
+ * explicitly; CI runs that don't want a real service install pass `dryRun: true`.
  */
 export async function runInitNonInteractive(
   cwd: string,
   opts: NonInteractiveOptions = {},
 ): Promise<ApplyResult> {
   const envs = await detectEditorEnvironments(cwd, opts.homeDir);
-  const detected = envs.filter((e) => e.present).map((e) => e.editor);
+  // v0.2.21: count both project-level (`present`) AND machine-level (`installed`) signals so
+  // the --yes path matches the interactive wizard's preselect logic.
+  const detected = envs.filter((e) => e.present || e.installed).map((e) => e.editor);
   const editors = opts.editors ?? (detected.length > 0 ? detected : envs.map((e) => e.editor));
-  const runMode = opts.runMode ?? "as-needed";
+  const runMode = opts.runMode ?? (editors.length >= 2 ? "always-running" : "as-needed");
   const search = opts.search ?? "keyword";
   const identity = await defaultIdentity();
   const answers: WizardAnswers = {

package/src/server/index.ts

@@ -48,7 +48,7 @@ import { type Requester } from "../access/scope";
 
 export type RequesterResolver = (extra: { authInfo?: AuthInfo }) => Requester;
 
-export const KRIMTO_VERSION = "0.2.19";
+export const KRIMTO_VERSION = "0.2.21";
 
 export function resolveDataDir(): string {
   return process.env.KRIMTO_DATA ?? path.join(homedir(), ".krimto");