@jmylchreest/aide-plugin 0.0.66 → 0.1.0

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

@@ -9,11 +9,22 @@
  *
  * Resolution order, matching main.go:findProjectRoot:
  *   1. AIDE_PROJECT_ROOT env override (must be an existing directory).
- *   2. Walk up from cwd. At each level:
- *      a. .aide/ — return this dir. Skip ~/.aide/ unless cwd === $HOME.
- *      b. .git/ directory — return this dir.
- *      c. .git/ file (worktree pointer) — resolve to the main repo root.
+ *   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";
@@ -53,42 +64,68 @@ export function findProjectRoot(cwd: string): ProjectRootResult {
   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 aidePath = join(dir, ".aide");
-    if (existsSync(aidePath)) {
-      // Skip ~/.aide/ unless cwd is $HOME itself. ~/.aide/ is the global
-      // config dir, not a project marker.
-      if (!(home && dir === home && startCwd !== home)) {
-        return { root: dir, hasMarker: true };
-      }
+    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 gitPath = join(dir, ".git");
-    if (existsSync(gitPath)) {
-      try {
-        const stat = statSync(gitPath);
-        if (stat.isDirectory()) {
-          return { root: dir, hasMarker: true };
-        }
-        if (stat.isFile()) {
-          const mainRoot = resolveWorktreeGitFile(gitPath);
-          if (mainRoot) {
-            return { root: mainRoot, hasMarker: true };
-          }
-          return { root: dir, hasMarker: true };
-        }
-      } catch {
-        return { root: dir, hasMarker: 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) {
-      return { root: startCwd, hasMarker: false };
-    }
+    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: "" };
 }
 
 /**

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");