tmux-ide 2.6.1 → 2.8.0

package/packages/daemon/src/tui/detect/manifest-loader.ts

@@ -30,9 +30,20 @@ import { join } from "node:path";
 import type { AgentManifest, Rule, StateRules } from "./manifest.ts";
 import { BUNDLED_MANIFESTS } from "./manifests.ts";
 
-/** Directory scanned for user override manifests. */
+/** Directory scanned for user override manifests. Honors `TMUX_IDE_HOME` (the
+ *  state-home override every other `~/.tmux-ide` consumer respects) so tests
+ *  never read a real user's overrides. */
 export function overrideDir(): string {
-  return join(homedir(), ".tmux-ide", "agent-detection");
+  const home = process.env.TMUX_IDE_HOME ?? join(homedir(), ".tmux-ide");
+  return join(home, "agent-detection");
+}
+
+/** The fetched manifest-pack file (`tmux-ide update --manifests` installs it;
+ *  see `lib/manifest-pack.ts` for the format + publish contract). Lives in a
+ *  SUBDIRECTORY so {@link readOverrideManifests}'s top-level `*.json` scan
+ *  never sees it — that is what keeps user files ABOVE the pack. */
+export function packFile(dir = overrideDir()): string {
+  return join(dir, "pack", "manifest-pack.json");
 }
 
 /**
@@ -156,7 +167,8 @@ function normalizeStates(m: AgentManifest): AgentManifest {
   if (m.states.blocked) states.blocked = m.states.blocked;
   if (m.states.working) states.working = m.states.working;
   if (m.states.done) states.done = m.states.done;
-  return { id: m.id, commands: m.commands, states };
+  const confidence = m.confidence === "tuned" ? "tuned" : "conservative";
+  return { id: m.id, commands: m.commands, states, confidence };
 }
 
 function warnOnce(path: string, reason: string): void {
@@ -166,11 +178,49 @@ function warnOnce(path: string, reason: string): void {
 }
 
 /**
- * Load the full manifest set: bundled + user overrides, merged. Does io on
- * every call — prefer {@link getManifests} for hot paths.
+ * Read the installed manifest PACK (fetched by `tmux-ide update --manifests`),
+ * or `[]` when none is installed. Thin io — a malformed pack file is skipped
+ * with a one-time stderr warning, never a throw (the pack was schema-validated
+ * at install time; this guards a hand-edited/corrupted file). Each entry gets
+ * the same structural validation + normalization as a user override file.
+ */
+export function readPackManifests(dir = overrideDir()): AgentManifest[] {
+  const path = packFile(dir);
+  let raw: string;
+  try {
+    raw = readFileSync(path, "utf8");
+  } catch {
+    // No pack installed (the common case).
+    return [];
+  }
+  try {
+    const parsed: unknown = JSON.parse(raw);
+    const manifests = (parsed as { manifests?: unknown })?.manifests;
+    if (!Array.isArray(manifests)) {
+      warnOnce(path, "not a manifest pack (missing manifests[])");
+      return [];
+    }
+    const valid: AgentManifest[] = [];
+    for (const entry of manifests) {
+      if (validateManifestShape(entry)) valid.push(normalizeStates(entry));
+      else warnOnce(path, "pack entry is not a valid AgentManifest — entry skipped");
+    }
+    return valid;
+  } catch (err) {
+    warnOnce(path, err instanceof Error ? err.message : String(err));
+    return [];
+  }
+}
+
+/**
+ * Load the full manifest set: bundled + pack + user overrides, merged in that
+ * PRECEDENCE order — a fetched pack refines the bundled set, and a user's own
+ * `agent-detection/*.json` file always beats both (it is merged LAST). Does io
+ * on every call — prefer {@link getManifests} for hot paths.
  */
 export function loadManifests(): AgentManifest[] {
-  return mergeManifests(BUNDLED_MANIFESTS, readOverrideManifests());
+  const withPack = mergeManifests(BUNDLED_MANIFESTS, readPackManifests());
+  return mergeManifests(withPack, readOverrideManifests());
 }
 
 /** Process-lifetime cache for the merged manifest set. */

package/packages/daemon/src/tui/detect/manifest.ts

@@ -40,6 +40,15 @@ export interface StateRules {
   done?: Rule;
 }
 
+/**
+ * How much trust the manifest's rules earn.
+ * - `tuned`: built from REAL captured screens (or the agent's own source
+ *   strings) — the markers are verbatim, not guessed.
+ * - `conservative`: best-effort from public knowledge; high-precision only, so
+ *   it can never false-positive on a plain prompt, but it may miss real states.
+ */
+export type ManifestConfidence = "tuned" | "conservative";
+
 /** A detection manifest for one or more pane commands. */
 export interface AgentManifest {
   /** Stable manifest id. */
@@ -48,6 +57,12 @@ export interface AgentManifest {
   commands: string[];
   /** Evidence rules per detectable state. */
   states: StateRules;
+  /**
+   * Evidence confidence (default `conservative` when omitted). Surfaced by
+   * `agent explain` so a user can see whether a verdict rests on real evidence
+   * or a best-effort heuristic. Purely informational — never affects matching.
+   */
+  confidence?: ManifestConfidence;
 }
 
 /** The states a manifest can positively detect (idle is inferred elsewhere). */
@@ -160,10 +175,31 @@ export function explain(
   return { state: winner ? winner.state : null, checked };
 }
 
+/** Escape a string for literal use inside a RegExp source. */
+function escapeRegex(s: string): string {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+/**
+ * Does `haystack` contain `needle` as a WHOLE alphanumeric segment (delimited
+ * by start/end or any non-alphanumeric)? `grok-build` contains the segment
+ * `grok`; `pip` does NOT contain the segment `pi`. This is what keeps short
+ * manifest command tokens (pi, devin, kimi — M25.4) from substring-matching
+ * unrelated commands (`pip`, `vi`, `api-server`).
+ */
+function containsSegment(haystack: string, needle: string): boolean {
+  if (!haystack.includes(needle)) return false;
+  return new RegExp(`(^|[^a-z0-9])${escapeRegex(needle)}([^a-z0-9]|$)`).test(haystack);
+}
+
 /**
  * Pick the manifest whose `commands` best match a pane's current command.
- * Prefers an exact (case-insensitive) match, then a substring match in either
- * direction. Returns undefined when nothing applies.
+ * Prefers an exact (case-insensitive) match, then a SEGMENT match in either
+ * direction — the command contains a manifest token as a whole segment
+ * (`grok-build` → `grok`, `.kilo` → `kilo`) or vice versa (`cursor` →
+ * `cursor-agent`). Raw substring matching was retired in M25.4: it made every
+ * short token a false-positive machine (`pi` ⊂ `pip`, `vi` ⊂ `devin`).
+ * Returns undefined when nothing applies.
  */
 export function pickManifest(
   command: string,
@@ -178,7 +214,7 @@ export function pickManifest(
   return manifests.find((m) =>
     m.commands.some((c) => {
       const name = c.toLowerCase();
-      return cmd.includes(name) || name.includes(cmd);
+      return containsSegment(cmd, name) || containsSegment(name, cmd);
     }),
   );
 }