@jmylchreest/aide-plugin 0.0.65 → 0.1.0

package/src/hooks/write-guard.ts

@@ -12,6 +12,8 @@
 import { readStdin } from "../lib/hook-utils.js";
 import { debug } from "../lib/logger.js";
 import { checkWriteGuard } from "../core/write-guard.js";
+import { findAideBinary } from "../core/aide-client.js";
+import { emitInjectionEvent } from "../core/read-tracking.js";
 
 const SOURCE = "write-guard";
 
@@ -48,14 +50,35 @@ async function main(): Promise<void> {
     const toolName = data.tool_name || "";
     const toolInput = data.tool_input || {};
     const cwd = data.cwd || process.cwd();
+    const sessionId = data.session_id || "";
 
     const result = checkWriteGuard(toolName, toolInput, cwd);
 
     if (!result.allowed) {
-      debug(
-        SOURCE,
-        `Advisory: Write to existing file: ${toolInput.file_path || toolInput.filePath || toolInput.path}`,
-      );
+      const filePath =
+        (toolInput.file_path as string) ||
+        (toolInput.filePath as string) ||
+        (toolInput.path as string) ||
+        "";
+      debug(SOURCE, `Advisory: Write to existing file: ${filePath}`);
+      try {
+        const binary = findAideBinary({
+          cwd,
+          pluginRoot:
+            process.env.AIDE_PLUGIN_ROOT || process.env.CLAUDE_PLUGIN_ROOT,
+        });
+        if (binary && result.message) {
+          emitInjectionEvent(binary, cwd, {
+            source: SOURCE,
+            subtype: "guard",
+            content: result.message,
+            sessionId,
+            attrs: { tool: toolName, ...(filePath ? { file: filePath } : {}) },
+          });
+        }
+      } catch {
+        // Non-fatal
+      }
       const output: HookOutput = {
         continue: true,
         hookSpecificOutput: {

package/src/lib/aide-downloader.ts

@@ -28,6 +28,8 @@ import { Readable, Transform } from "stream";
 import { pipeline } from "stream/promises";
 // Canonical binary finder — import for local use, re-export for backward compat
 import { findAideBinary } from "./hook-utils.js";
+import { findProjectRoot } from "./project-root.js";
+import { loadGlobalConfig } from "../core/session-init.js";
 export { findAideBinary };
 
 export interface DownloadResult {
@@ -544,8 +546,24 @@ Downloads the aide binary from GitHub releases.
     }
     destDir = join(pluginRoot, "bin");
   } else if (!destDir) {
-    // Default to current directory's .aide/bin
-    destDir = join(process.cwd(), ".aide", "bin");
+    // Default: resolve to the project root rather than blindly using cwd.
+    // Matches the SessionStart hook so the CLI fallback never plants an
+    // orphan .aide/bin/ in a subdirectory of a git repo.
+    const { root, hasMarker } = findProjectRoot(process.cwd());
+    if (!hasMarker) {
+      const requireGit = loadGlobalConfig().requireGit ?? true;
+      if (requireGit) {
+        console.error(
+          `[aide] No .git/ or .aide/ found walking up from ${process.cwd()}. ` +
+            `Set \`requireGit\`: false in ~/.aide/config/aide.json or pass --cwd / --dest to install anyway.`,
+        );
+        process.exit(1);
+      }
+      console.error(
+        `[aide] No project root found, installing into ${process.cwd()} (requireGit=false).`,
+      );
+    }
+    destDir = join(hasMarker ? root : process.cwd(), ".aide", "bin");
   }
 
   const result = await downloadAideBinary(destDir, { force, quiet: false });

package/src/lib/hook-utils.ts

@@ -93,6 +93,69 @@ export function detectPlatform(): "claude-code" | "codex" {
   return "claude-code";
 }
 
+import { existsSync, readFileSync } from "fs";
+import { join } from "path";
+import { findProjectRoot } from "./project-root.js";
+
+const TRUTHY = new Set(["1", "true", "on", "yes"]);
+const FALSY = new Set(["0", "false", "off", "no"]);
+
+/**
+ * isTruthy reports whether an env-var value should be treated as "on".
+ * Accepts the same set as the Go config helper: 1/true/on/yes
+ * (case-insensitive, whitespace-trimmed). Use for opt-in flags.
+ */
+export function isTruthy(v: string | undefined): boolean {
+  if (!v) return false;
+  return TRUTHY.has(v.trim().toLowerCase());
+}
+
+/**
+ * isFalsy reports whether an env-var value was explicitly set to disable.
+ * Accepts 0/false/off/no. Unset/empty/unknown values return false so the
+ * caller's default-on behaviour wins. Use for opt-out flags.
+ */
+export function isFalsy(v: string | undefined): boolean {
+  if (!v) return false;
+  return FALSY.has(v.trim().toLowerCase());
+}
+
+/**
+ * reflectEnabled mirrors the Go-side config.ResolveReflectEnabled precedence
+ * so TS hooks that need to gate on the reflect setting see the same answer
+ * as `aide reflect run`. Precedence:
+ *
+ *   1. AIDE_REFLECT env (recognised truthy/falsy values win)
+ *   2. .aide/config/aide.json `reflect.enabled` at the resolved project
+ *      root (walks up from cwd via findProjectRoot — does NOT just look
+ *      at cwd/.aide/)
+ *   3. default false
+ *
+ * Used by skill-injector.ts and opencode/hooks.ts to gate the user_prompt
+ * observe-event emit that convergence detection depends on.
+ */
+export function reflectEnabled(cwd: string): boolean {
+  const env = process.env.AIDE_REFLECT;
+  if (env !== undefined && env !== "") {
+    const norm = env.trim().toLowerCase();
+    if (TRUTHY.has(norm)) return true;
+    if (FALSY.has(norm)) return false;
+  }
+  try {
+    const { root } = findProjectRoot(cwd);
+    const cfgPath = join(root, ".aide", "config", "aide.json");
+    if (existsSync(cfgPath)) {
+      const cfg = JSON.parse(readFileSync(cfgPath, "utf-8")) as {
+        reflect?: { enabled?: boolean };
+      };
+      return cfg?.reflect?.enabled === true;
+    }
+  } catch {
+    // Unreadable / malformed config — treat as unset.
+  }
+  return false;
+}
+
 /**
  * Get the plugin root directory from environment variables.
  */

package/src/lib/hud.ts

@@ -9,6 +9,7 @@ import { existsSync, readFileSync, writeFileSync, mkdirSync } from "fs";
 import { join } from "path";
 import { execFileSync } from "child_process";
 import { runAide, findAideBinary } from "./hook-utils.js";
+import { findProjectRoot } from "./project-root.js";
 
 // Cache the aide version for the session (won't change)
 let aideVersionCache: string | null = null;
@@ -149,7 +150,8 @@ export function getAgentStates(cwd: string): AgentState[] {
  * Load HUD configuration
  */
 export function loadHudConfig(cwd: string): HudConfig {
-  const configPath = join(cwd, ".aide", "config", "hud.json");
+  const { root } = findProjectRoot(cwd);
+  const configPath = join(root, ".aide", "config", "hud.json");
 
   if (existsSync(configPath)) {
     try {
@@ -444,7 +446,8 @@ export function formatHud(
  * Write HUD output to state file
  */
 export function writeHudOutput(cwd: string, output: string): void {
-  const stateDir = join(cwd, ".aide", "state");
+  const { root } = findProjectRoot(cwd);
+  const stateDir = join(root, ".aide", "state");
   if (!existsSync(stateDir)) {
     try {
       mkdirSync(stateDir, { recursive: true });

package/src/lib/logger.ts

@@ -21,6 +21,7 @@
 
 import { existsSync, mkdirSync, appendFileSync } from "fs";
 import { join } from "path";
+import { findProjectRoot } from "./project-root.js";
 
 export type LogLevel = "debug" | "info" | "warn" | "error";
 
@@ -51,10 +52,14 @@ export class Logger {
   constructor(source: string, cwd?: string) {
     this.source = source;
     this.cwd = cwd || process.cwd();
-    // Set debugLogCwd so isDebugEnabled() can check the sentinel file
-    if (cwd) setDebugCwd(cwd);
+    // Resolve to the canonical project root so logs land alongside the
+    // real .aide/ store, not in a stray subdir the harness launched from.
+    const { root } = findProjectRoot(this.cwd);
+    // Set debugLogCwd so isDebugEnabled() can check the sentinel file at
+    // the resolved root.
+    setDebugCwd(root);
     this.enabled = isDebugEnabled();
-    this.logDir = join(this.cwd, ".aide", "_logs");
+    this.logDir = join(root, ".aide", "_logs");
     this.logFile = join(this.logDir, "startup.log");
     this.sessionStart = Date.now();
 
@@ -288,11 +293,13 @@ export function isDebugEnabled(): boolean {
   const debugEnv = process.env.AIDE_DEBUG || "";
   if (debugEnv === "1" || debugEnv === "true") return true;
 
-  // Check sentinel file (cached per cwd)
+  // Check sentinel file (cached per cwd). Resolve to project root so the
+  // sentinel works regardless of which subdir the hook fired from.
   if (debugLogCwd !== debugSentinelCwd) {
     debugSentinelCwd = debugLogCwd;
     try {
-      debugSentinelResult = existsSync(join(debugLogCwd, ".aide", ".debug"));
+      const { root } = findProjectRoot(debugLogCwd);
+      debugSentinelResult = existsSync(join(root, ".aide", ".debug"));
     } catch {
       debugSentinelResult = false;
     }
@@ -303,6 +310,10 @@ export function isDebugEnabled(): boolean {
 /**
  * Set the working directory for debug logging.
  * Call this after parsing stdin to use project-local logs.
+ *
+ * Note: callers may pass either the raw cwd or an already-resolved project
+ * root. Logger's constructor resolves cwd → root before calling this; bare
+ * callers of debug() may pass cwd and we'll resolve at use-time.
  */
 export function setDebugCwd(cwd: string): void {
   debugLogCwd = cwd;
@@ -326,7 +337,8 @@ export function setDebugCwd(cwd: string): void {
 export function debug(source: string, msg: string): void {
   if (!isDebugEnabled()) return;
 
-  const logDir = join(debugLogCwd, ".aide", "_logs");
+  const { root } = findProjectRoot(debugLogCwd);
+  const logDir = join(root, ".aide", "_logs");
   try {
     if (!existsSync(logDir)) {
       mkdirSync(logDir, { recursive: true });

package/src/lib/project-root.ts

@@ -0,0 +1,174 @@
+/**
+ * Project root resolution for the AIDE plugin.
+ *
+ * Mirrors the Go binary's findProjectRoot() in aide/cmd/aide/main.go so that
+ * the TypeScript hook layer and the Go binary always agree on where `.aide/`
+ * lives. Without this, the hook would plant a sibling `.aide/` in whatever
+ * subdirectory `claude` was launched from, while the Go binary would walk up
+ * and use the real one at the repo root.
+ *
+ * Resolution order, matching main.go:findProjectRoot:
+ *   1. AIDE_PROJECT_ROOT env override (must be an existing directory).
+ *   2. Walk the full ancestry from cwd to /, collecting candidates, then
+ *      prefer:
+ *        a. Closest ancestor with BOTH .aide/ and a VCS marker
+ *           (.git/.hg/.svn/.bzr/.fossil) — handles the common case where
+ *           the canonical root sits at the git repo root.
+ *        b. Closest ancestor with a VCS marker only — .aide/ will be
+ *           created there if needed.
+ *        c. Closest ancestor with .aide/ only — standalone projects with
+ *           no VCS.
+ *      ~/.aide/ is skipped as a project marker unless cwd is $HOME.
+ *   3. No marker found: return { root: cwd, hasMarker: false }.
+ *
+ * The "both markers wins" priority is what stops a stray child .aide/ from
+ * shadowing the real project root: a sibling .aide/ created by an
+ * accidental CLI invocation lives in a subdir with no .git/, so the walk
+ * keeps going until it finds the parent that has both.
+ */
+
+import { basename, dirname, join, resolve } from "path";
+import { existsSync, readFileSync, statSync } from "fs";
+import { homedir } from "os";
+
+export interface ProjectRootResult {
+  root: string;
+  hasMarker: boolean;
+}
+
+/**
+ * Resolve the AIDE project root for a given cwd.
+ *
+ * `hasMarker` is true when an actual `.aide/` or `.git/` marker was found
+ * (or when AIDE_PROJECT_ROOT is set to an existing directory). When false,
+ * `root` is just the input cwd — callers should decide whether to fall
+ * back to it (e.g. via the `requireGit` config) or refuse to bootstrap.
+ */
+export function findProjectRoot(cwd: string): ProjectRootResult {
+  const override = process.env.AIDE_PROJECT_ROOT;
+  if (override) {
+    try {
+      const abs = resolve(override);
+      const stat = statSync(abs);
+      if (stat.isDirectory()) {
+        return { root: abs, hasMarker: true };
+      }
+    } catch {
+      // Fall through to the walk-up.
+    }
+    process.stderr.write(
+      `aide: AIDE_PROJECT_ROOT=${JSON.stringify(override)} is not a directory; falling back to walk-up\n`,
+    );
+  }
+
+  const startCwd = resolve(cwd);
+  const home = homedir();
+
+  interface Candidate {
+    dir: string;
+    hasAide: boolean;
+    hasVCS: boolean;
+    vcsResolved: string;
+  }
+  const path: Candidate[] = [];
+
+  let dir = startCwd;
+  for (;;) {
+    const cand: Candidate = { dir, hasAide: false, hasVCS: false, vcsResolved: "" };
+
+    if (existsSync(join(dir, ".aide"))) {
+      // Skip ~/.aide/ unless cwd is $HOME itself.
+      const isHomeAide = home && dir === home && startCwd !== home;
+      if (!isHomeAide) cand.hasAide = true;
+    }
+
+    const vcs = vcsMarkerAt(dir);
+    if (vcs.ok) {
+      cand.hasVCS = true;
+      cand.vcsResolved = vcs.resolved || dir;
+    }
+
+    if (cand.hasAide || cand.hasVCS) path.push(cand);
+
+    const parent = dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+
+  for (const c of path) {
+    if (c.hasAide && c.hasVCS) return { root: c.vcsResolved, hasMarker: true };
+  }
+  for (const c of path) {
+    if (c.hasVCS) return { root: c.vcsResolved, hasMarker: true };
+  }
+  for (const c of path) {
+    if (c.hasAide) return { root: c.dir, hasMarker: true };
+  }
+  return { root: startCwd, hasMarker: false };
+}
+
+function vcsMarkerAt(dir: string): { ok: boolean; resolved: string } {
+  const gitPath = join(dir, ".git");
+  if (existsSync(gitPath)) {
+    try {
+      const st = statSync(gitPath);
+      if (st.isDirectory()) return { ok: true, resolved: dir };
+      if (st.isFile()) {
+        const mainRoot = resolveWorktreeGitFile(gitPath);
+        return { ok: true, resolved: mainRoot || dir };
+      }
+      return { ok: true, resolved: dir };
+    } catch {
+      return { ok: true, resolved: dir };
+    }
+  }
+  for (const marker of [".hg", ".svn", ".bzr", ".fossil"]) {
+    if (existsSync(join(dir, marker))) return { ok: true, resolved: dir };
+  }
+  return { ok: false, resolved: "" };
+}
+
+/**
+ * Walk up from `startDir` looking for `.aide/` or `.git/` markers.
+ * Returns the resolved root directory, or null when nothing is found.
+ *
+ * Thin wrapper around findProjectRoot for callers that want a nullable
+ * result rather than the {root,hasMarker} shape (e.g. the OpenCode plugin
+ * which has its own fallback chain).
+ */
+export function walkUpForProjectRoot(startDir: string): string | null {
+  const { root, hasMarker } = findProjectRoot(startDir);
+  return hasMarker ? root : null;
+}
+
+/**
+ * Read a .git worktree file ("gitdir: <path>") and return the main repo root.
+ *
+ * Mirrors aide/cmd/aide/main.go:resolveWorktreeRoot(). The file's gitdir
+ * normally points at "<main>/.git/worktrees/<name>"; we walk up that path
+ * until we find a component named ".git" and return its parent.
+ */
+export function resolveWorktreeGitFile(gitFilePath: string): string | null {
+  try {
+    const content = readFileSync(gitFilePath, "utf-8").trim();
+    if (!content.startsWith("gitdir:")) return null;
+
+    let gitdir = content.slice("gitdir:".length).trim();
+    if (!gitdir.startsWith("/")) {
+      gitdir = resolve(dirname(gitFilePath), gitdir);
+    }
+
+    let candidate = gitdir;
+    for (;;) {
+      const parent = dirname(candidate);
+      if (parent === candidate) break;
+      if (basename(candidate) === ".git") {
+        return parent;
+      }
+      candidate = parent;
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}

package/src/opencode/hooks.ts

@@ -52,12 +52,14 @@ import { checkWriteGuard } from "../core/write-guard.js";
 import { checkSmartReadHint } from "../core/context-guard.js";
 import { checkSearchEnrichment } from "../core/search-enrichment.js";
 import { recordToolEvent } from "../core/tool-observe.js";
+import { recordObserveEvent, previewContent } from "../core/read-tracking.js";
 import {
   checkComments,
   getCheckableFilePath,
   getContentToCheck,
 } from "../core/comment-checker.js";
 import { getState, setState } from "../core/aide-client.js";
+import { isFalsy, reflectEnabled } from "../lib/hook-utils.js";
 import { saveStateSnapshot } from "../core/pre-compact-logic.js";
 import { cleanupSession } from "../core/cleanup.js";
 import {
@@ -335,11 +337,16 @@ function initializeAide(state: AideState): void {
 
     ensureDirectories(state.cwd);
 
-    // Sync MCP server configs across assistants (FS only, fast)
-    try {
-      syncMcpServers("opencode", state.cwd);
-    } catch (err) {
-      debug(SOURCE, `MCP sync failed (non-fatal): ${err}`);
+    // Sync MCP server configs across assistants (FS only, fast).
+    // Opt-out via AIDE_MCP_SYNC=0 (defaults to enabled).
+    if (isFalsy(process.env.AIDE_MCP_SYNC)) {
+      debug(SOURCE, "MCP sync disabled (AIDE_MCP_SYNC falsy)");
+    } else {
+      try {
+        syncMcpServers("opencode", state.cwd);
+      } catch (err) {
+        debug(SOURCE, `MCP sync failed (non-fatal): ${err}`);
+      }
     }
 
     const config = loadConfig(state.cwd);
@@ -592,6 +599,22 @@ async function handleSessionIdle(
       cleanupPartials(state.binary, state.cwd, sessionId);
     }
   }
+
+  // Reflect (extract instinct proposals). The CLI itself checks env +
+  // .aide/config/aide.json reflect.enabled and no-ops when disabled, so
+  // invoke unconditionally. Mirrors the Claude Code Stop hook.
+  if (state.binary) {
+    try {
+      execFileSync(state.binary, ["reflect", "run", `--session=${sessionId}`], {
+        cwd: state.cwd,
+        timeout: 10000,
+        stdio: ["pipe", "pipe", "pipe"],
+      });
+      debug(SOURCE, `reflect run session=${sessionId.slice(0, 8)} ok`);
+    } catch (err) {
+      debug(SOURCE, `reflect run failed (non-fatal): ${err}`);
+    }
+  }
 }
 
 async function handleSessionDeleted(
@@ -647,6 +670,24 @@ async function handleMessagePartUpdated(
   // this event fires after the transform (defensive against ordering).
   state.lastUserPrompt = prompt;
 
+  // Emit a user-prompt observe event so the convergence detector can find
+  // corrective markers near edit sequences. Gated behind AIDE_REFLECT,
+  // mirroring src/hooks/skill-injector.ts for cross-harness parity.
+  if (state.binary && reflectEnabled(state.cwd)) {
+    try {
+      recordObserveEvent(state.binary, state.cwd, {
+        kind: "hook",
+        name: "user_prompt",
+        category: "input",
+        tokens: Math.round(prompt.length / 3.0),
+        session: extractSessionId(event),
+        attrs: { text: previewContent(prompt, 2000) },
+      });
+    } catch {
+      // Non-fatal
+    }
+  }
+
   const skills = discoverSkills(state.cwd, state.pluginRoot ?? undefined);
   const matched = matchSkills(prompt, skills, 3, "opencode");
 

package/src/opencode/index.ts

@@ -36,11 +36,11 @@
  * ```
  */
 
-import { basename, dirname, join, resolve } from "path";
+import { dirname, join, resolve } from "path";
 import { fileURLToPath } from "url";
-import { existsSync, readFileSync, statSync } from "fs";
 import { createHooks } from "./hooks.js";
 import { isDebugEnabled } from "../lib/logger.js";
+import { walkUpForProjectRoot } from "../lib/project-root.js";
 import type { Plugin, PluginInput, Hooks } from "./types.js";
 
 // Resolve the plugin package root so we can find bundled skills.
@@ -121,84 +121,6 @@ function resolveProjectRoot(ctx: PluginInput): {
   return { root: directory || "/", hasProjectRoot: false };
 }
 
-/**
- * Walk up from `startDir` looking for .aide/ or .git/ directories.
- * Returns the project root path, or null if none found.
- *
- * For git worktrees, .git is a file containing "gitdir: <path>".
- * We follow it to the main repo root, matching the Go binary's
- * resolveWorktreeRoot() behavior.
- */
-function walkUpForProjectRoot(startDir: string): string | null {
-  let dir = resolve(startDir);
-  for (;;) {
-    if (existsSync(join(dir, ".aide"))) {
-      return dir;
-    }
-    const gitPath = join(dir, ".git");
-    if (existsSync(gitPath)) {
-      try {
-        const stat = statSync(gitPath);
-        if (stat.isDirectory()) {
-          // Normal git repo
-          return dir;
-        }
-        if (stat.isFile()) {
-          // Worktree: .git is a file containing "gitdir: <path>"
-          // Follow it to the main repo root.
-          const mainRoot = resolveWorktreeGitFile(gitPath);
-          if (mainRoot) return mainRoot;
-          // Fallback to current dir if resolution fails
-          return dir;
-        }
-      } catch {
-        return dir;
-      }
-    }
-    const parent = resolve(dir, "..");
-    if (parent === dir) {
-      return null;
-    }
-    dir = parent;
-  }
-}
-
-/**
- * Read a .git worktree file and resolve to the main repository root.
- * Mirrors the Go binary's resolveWorktreeRoot() in main.go.
- *
- * The file contains "gitdir: /path/to/repo/.git/worktrees/<name>".
- * We walk up from that gitdir path to find the .git directory,
- * then return its parent.
- */
-function resolveWorktreeGitFile(gitFilePath: string): string | null {
-  try {
-    const content = readFileSync(gitFilePath, "utf-8").trim();
-    if (!content.startsWith("gitdir:")) return null;
-
-    let gitdir = content.slice("gitdir:".length).trim();
-    // Make absolute if relative
-    if (!gitdir.startsWith("/")) {
-      gitdir = resolve(dirname(gitFilePath), gitdir);
-    }
-
-    // Walk up from .git/worktrees/<name> to find the .git directory,
-    // then return its parent as the repo root.
-    let candidate = gitdir;
-    for (;;) {
-      const parent = dirname(candidate);
-      if (parent === candidate) break;
-      if (basename(candidate) === ".git") {
-        return parent;
-      }
-      candidate = parent;
-    }
-    return null;
-  } catch {
-    return null;
-  }
-}
-
 export const AidePlugin: Plugin = async (ctx: PluginInput): Promise<Hooks> => {
   // Log raw plugin input BEFORE any resolution for diagnostics.
   // This is the key to understanding what OpenCode actually passes.