@jmylchreest/aide-plugin 0.0.64 → 0.0.66

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jmylchreest/aide-plugin",
-  "version": "0.0.64",
+  "version": "0.0.66",
   "description": "aide plugin for OpenCode and Codex CLI — multi-agent orchestration, memory, skills, and persistence",
   "type": "module",
   "main": "./src/opencode/index.ts",
@@ -52,7 +52,7 @@
   },
   "dependencies": {
     "cross-spawn": "^7.0.6",
-    "smol-toml": "^1.3.1",
-    "which": "^6.0.1"
+    "smol-toml": "^1.6.1",
+    "which": "^7.0.0"
   }
 }

package/src/core/session-init.ts

@@ -186,23 +186,39 @@ export function getProjectName(cwd: string): string {
 }
 
 /**
- * Load config from .aide/config/aide.json (if it exists).
- * Returns DEFAULT_CONFIG if no config file exists or it can't be parsed.
+ * Load config from ~/.aide/config/aide.json (global).
+ * Used before a project root has been resolved (e.g. by the SessionStart
+ * hook deciding whether to honour `requireGit`).
+ */
+export function loadGlobalConfig(): AideConfig {
+  const configPath = join(homedir(), ".aide", "config", "aide.json");
+  if (!existsSync(configPath)) return DEFAULT_CONFIG;
+  try {
+    return { ...DEFAULT_CONFIG, ...JSON.parse(readFileSync(configPath, "utf-8")) };
+  } catch {
+    return DEFAULT_CONFIG;
+  }
+}
+
+/**
+ * Load config layered as: defaults → global (~/.aide/config/aide.json) →
+ * project (`<cwd>/.aide/config/aide.json`). Project values override global.
  * Does NOT create a default config file — only user-set values are persisted.
  */
 export function loadConfig(cwd: string): AideConfig {
-  const configPath = join(cwd, ".aide", "config", "aide.json");
+  const global = loadGlobalConfig();
+  const projectPath = join(cwd, ".aide", "config", "aide.json");
 
-  if (existsSync(configPath)) {
+  if (existsSync(projectPath)) {
     try {
-      const content = readFileSync(configPath, "utf-8");
-      return { ...DEFAULT_CONFIG, ...JSON.parse(content) };
+      const project = JSON.parse(readFileSync(projectPath, "utf-8"));
+      return { ...DEFAULT_CONFIG, ...global, ...project };
     } catch {
-      return DEFAULT_CONFIG;
+      return global;
     }
   }
 
-  return DEFAULT_CONFIG;
+  return global;
 }
 
 /**

package/src/core/types.ts

@@ -9,6 +9,16 @@
 // =============================================================================
 
 export interface AideConfig {
+  /**
+   * When true (default), AIDE refuses to bootstrap if no `.git/` or `.aide/`
+   * marker is found walking up from the launched cwd. This prevents the hook
+   * from planting an orphan `.aide/` folder in an arbitrary subdirectory of a
+   * git repo when `claude` is launched there. Set to false in
+   * `~/.aide/config/aide.json` to allow init in non-git directories.
+   * Only the global-config value is consulted (the project layer is moot
+   * because, if a project root was found, the gate has already passed).
+   */
+  requireGit?: boolean;
   share?: {
     /** Auto-import shared data from .aide/shared/ on session start (default: false) */
     autoImport?: boolean;

package/src/hooks/session-start.ts

@@ -26,10 +26,12 @@ import { homedir } from "os";
 import { Logger, debug, setDebugCwd } from "../lib/logger.js";
 import { readStdin, detectPlatform } from "../lib/hook-utils.js";
 import { findAideBinary, ensureAideBinary } from "../lib/aide-downloader.js";
+import { findProjectRoot } from "../lib/project-root.js";
 import { recordTokenEvent } from "../core/read-tracking.js";
 import {
   ensureDirectories as coreEnsureDirectories,
   loadConfig as coreLoadConfig,
+  loadGlobalConfig as coreLoadGlobalConfig,
   initializeSession as coreInitializeSession,
   cleanupStaleStateFiles as coreCleanupStaleStateFiles,
   resetHudState as coreResetHudState,
@@ -340,13 +342,35 @@ async function main(): Promise<void> {
     }
 
     const data: HookInput = JSON.parse(input);
-    const cwd = data.cwd || process.cwd();
+    const launchedCwd = data.cwd || process.cwd();
     const sessionId = data.session_id || "unknown";
 
+    // Resolve the project root so we never plant a sibling .aide/ in a
+    // subdirectory of a git repo. Mirrors the Go binary's findProjectRoot().
+    const { root: resolvedRoot, hasMarker } = findProjectRoot(launchedCwd);
+    if (!hasMarker) {
+      const requireGit = coreLoadGlobalConfig().requireGit ?? true;
+      if (requireGit) {
+        process.stderr.write(
+          `[aide] No .git/ or .aide/ found walking up from ${launchedCwd}. ` +
+            `Set \`requireGit\`: false in ~/.aide/config/aide.json to allow ` +
+            `init in arbitrary directories. Skipping AIDE bootstrap.\n`,
+        );
+        console.log(JSON.stringify({ continue: true }));
+        return;
+      }
+      process.stderr.write(
+        `[aide] No project root found, falling back to ${launchedCwd} (requireGit=false).\n`,
+      );
+    }
+    const cwd = hasMarker ? resolvedRoot : launchedCwd;
+
     // Switch debug logging to project-local logs
     setDebugCwd(cwd);
 
-    debugLog(`Parsed input: cwd=${cwd}, sessionId=${sessionId.slice(0, 8)}`);
+    debugLog(
+      `Parsed input: cwd=${cwd}, launchedCwd=${launchedCwd}, sessionId=${sessionId.slice(0, 8)}`,
+    );
 
     // Initialize logger
     log = new Logger("session-start", cwd);

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/project-root.ts

@@ -0,0 +1,137 @@
+/**
+ * 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 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.
+ *   3. No marker found: return { root: cwd, hasMarker: false }.
+ */
+
+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();
+
+  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 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 parent = dirname(dir);
+    if (parent === dir) {
+      return { root: startCwd, hasMarker: false };
+    }
+    dir = parent;
+  }
+}
+
+/**
+ * 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/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.