@jmylchreest/aide-plugin 0.0.36 → 0.0.37

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jmylchreest/aide-plugin",
-  "version": "0.0.36",
+  "version": "0.0.37",
   "description": "aide plugin for OpenCode — multi-agent orchestration, memory, skills, and persistence",
   "type": "module",
   "main": "./src/opencode/index.ts",

package/src/opencode/hooks.ts

@@ -98,6 +98,8 @@ interface AideState {
   worktree: string;
   /** Root of the aide plugin package (for finding bundled skills) */
   pluginRoot: string | null;
+  /** Skip initializing aide for non-project directories */
+  skipInit: boolean;
   sessionState: SessionState | null;
   memories: MemoryInjection | null;
   welcomeContext: string | null;
@@ -122,6 +124,7 @@ export async function createHooks(
   worktree: string,
   client: OpenCodeClient,
   pluginRoot?: string,
+  options?: { skipInit?: boolean },
 ): Promise<Hooks> {
   const state: AideState = {
     initialized: false,
@@ -129,6 +132,7 @@ export async function createHooks(
     cwd,
     worktree,
     pluginRoot: pluginRoot || null,
+    skipInit: options?.skipInit ?? false,
     sessionState: null,
     memories: null,
     welcomeContext: null,
@@ -143,6 +147,18 @@ export async function createHooks(
   // Run one-time initialization (directories, binary, config)
   initializeAide(state);
 
+  try {
+    await client.app.log({
+      body: {
+        service: "aide",
+        level: "info",
+        message: `aide hooks init: cwd=${state.cwd} worktree=${state.worktree} pluginRoot=${state.pluginRoot ?? "unknown"} binary=${state.binary ?? "not-found"} skipInit=${state.skipInit}`,
+      },
+    });
+  } catch (err) {
+    debug(SOURCE, `Init log failed (non-fatal): ${err}`);
+  }
+
   return {
     event: createEventHandler(state),
     config: createConfigHandler(state),
@@ -250,6 +266,15 @@ function createCommandHandler(state: AideState): (
 
 function initializeAide(state: AideState): void {
   try {
+    if (state.skipInit) {
+      debug(
+        SOURCE,
+        `Initialization skipped (no git root detected): ${state.cwd}`,
+      );
+      state.initialized = true;
+      return;
+    }
+
     ensureDirectories(state.cwd);
 
     // Sync MCP server configs across assistants (FS only, fast)
@@ -263,7 +288,10 @@ function initializeAide(state: AideState): void {
     cleanupStaleStateFiles(state.cwd);
     resetHudState(state.cwd);
 
-    state.binary = findAideBinary({ cwd: state.cwd });
+    state.binary = findAideBinary({
+      cwd: state.cwd,
+      pluginRoot: state.pluginRoot || undefined,
+    });
 
     if (state.binary) {
       const projectName = getProjectName(state.cwd);

package/src/opencode/index.ts

@@ -8,6 +8,13 @@
  *   - As a local plugin: copy/symlink to .opencode/plugins/
  *   - As an npm package: add "@jmylchreest/aide-plugin" to opencode.json
  *
+ * Environment variables:
+ *   AIDE_FORCE_INIT=1  Force aide initialization even in non-git directories.
+ *                      By default, aide skips initialization when no .git/ or
+ *                      .aide/ directory is found. Set this in the MCP server's
+ *                      "environment" config to always create .aide/ in the
+ *                      working directory.
+ *
  * @example opencode.json
  * ```json
  * {
@@ -17,7 +24,11 @@
  *     "aide": {
  *       "type": "local",
  *       "command": ["bunx", "-y", "@jmylchreest/aide-plugin", "mcp"],
- *       "environment": { "AIDE_CODE_WATCH": "1", "AIDE_CODE_WATCH_DELAY": "30s" },
+ *       "environment": {
+ *         "AIDE_CODE_WATCH": "1",
+ *         "AIDE_CODE_WATCH_DELAY": "30s",
+ *         "AIDE_FORCE_INIT": "1"
+ *       },
  *       "enabled": true
  *     }
  *   }
@@ -25,8 +36,9 @@
  * ```
  */
 
-import { dirname, join } from "path";
+import { dirname, join, resolve } from "path";
 import { fileURLToPath } from "url";
+import { existsSync, statSync } from "fs";
 import { createHooks } from "./hooks.js";
 import type { Plugin, PluginInput, Hooks } from "./types.js";
 
@@ -37,9 +49,132 @@ const __dirname = dirname(__filename);
 // index.ts lives in src/opencode/, so the package root is two levels up.
 const pluginRoot = join(__dirname, "..", "..");
 
+if (!process.env.AIDE_PLUGIN_ROOT) {
+  process.env.AIDE_PLUGIN_ROOT = pluginRoot;
+}
+
+/**
+ * Resolve the project root directory from the OpenCode plugin context.
+ *
+ * OpenCode provides three directory-related values:
+ *   ctx.worktree  — `git rev-parse --show-toplevel` (sandbox root, "/" for non-git)
+ *   ctx.directory — `process.cwd()` or `--dir` (where OpenCode was invoked)
+ *   ctx.project.worktree — `dirname(git rev-parse --git-common-dir)` (main repo root)
+ *
+ * Priority:
+ *   1. ctx.worktree — the git sandbox root (correct for both normal repos and worktrees)
+ *   2. ctx.directory — where OpenCode was invoked (fallback for non-git)
+ *
+ * Both ctx.worktree and ctx.directory are "/" for non-git projects, so we
+ * detect that case and skip initialization.
+ */
+function resolveProjectRoot(ctx: PluginInput): {
+  root: string;
+  hasProjectRoot: boolean;
+} {
+  // ctx.worktree is the git working tree root (from `git rev-parse --show-toplevel`).
+  // For non-git projects, OpenCode sets this to "/".
+  const worktree = ctx.worktree;
+  const directory = ctx.directory;
+
+  // OpenCode sets worktree to "/" for non-git projects — treat as no project.
+  // Also guard against empty strings.
+  const isNonGitWorktree = !worktree || worktree === "/";
+
+  if (!isNonGitWorktree) {
+    // The worktree is a valid git root — use it directly.
+    // No need to walk up the filesystem; OpenCode already resolved it.
+    return { root: resolve(worktree), hasProjectRoot: true };
+  }
+
+  // Worktree is "/" (non-git) — try to find a project root from the directory.
+  // This handles the case where the user is in a git repo but OpenCode's
+  // resolution somehow failed, or where .aide/ already exists.
+  if (directory && directory !== "/") {
+    const resolved = walkUpForProjectRoot(directory);
+    if (resolved) {
+      return { root: resolved, hasProjectRoot: true };
+    }
+  }
+
+  // No git root found anywhere.
+  // If AIDE_FORCE_INIT is set, treat the directory as the project root anyway.
+  const forceInit = !!process.env.AIDE_FORCE_INIT;
+  if (forceInit && directory && directory !== "/") {
+    return { root: resolve(directory), hasProjectRoot: true };
+  }
+
+  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.
+ */
+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);
+        // .git can be a directory (normal repo) or a file (worktree pointer)
+        if (stat.isDirectory() || stat.isFile()) {
+          return dir;
+        }
+      } catch {
+        return dir;
+      }
+    }
+    const parent = resolve(dir, "..");
+    if (parent === dir) {
+      return null;
+    }
+    dir = parent;
+  }
+}
+
 export const AidePlugin: Plugin = async (ctx: PluginInput): Promise<Hooks> => {
-  const cwd = ctx.worktree || ctx.directory;
-  return createHooks(cwd, ctx.worktree, ctx.client, pluginRoot);
+  // Log raw plugin input BEFORE any resolution for diagnostics.
+  // This is the key to understanding what OpenCode actually passes.
+  const rawLog = [
+    `aide plugin init (raw ctx):`,
+    `  ctx.directory = ${JSON.stringify(ctx.directory)}`,
+    `  ctx.worktree  = ${JSON.stringify(ctx.worktree)}`,
+    `  ctx.project   = ${JSON.stringify(ctx.project, null, 2)?.split("\n").join("\n  ")}`,
+  ].join("\n");
+
+  // Best-effort log to OpenCode's log system
+  try {
+    await ctx.client.app.log({
+      body: { service: "aide", level: "info", message: rawLog },
+    });
+  } catch {
+    // Plugin may be called before the client is fully ready
+  }
+
+  // Also log to stderr for direct observability
+  console.error(rawLog);
+
+  const resolved = resolveProjectRoot(ctx);
+
+  const forceInit = !!process.env.AIDE_FORCE_INIT;
+  const resolvedLog = `aide plugin resolved: root=${resolved.root} hasProjectRoot=${resolved.hasProjectRoot}${forceInit ? " (AIDE_FORCE_INIT=1)" : ""}`;
+  try {
+    await ctx.client.app.log({
+      body: { service: "aide", level: "info", message: resolvedLog },
+    });
+  } catch {
+    // non-fatal
+  }
+  console.error(resolvedLog);
+
+  return createHooks(resolved.root, ctx.worktree, ctx.client, pluginRoot, {
+    skipInit: !resolved.hasProjectRoot,
+  });
 };
 
 export default AidePlugin;

package/src/opencode/types.ts

@@ -13,14 +13,58 @@
 // Plugin Input (provided by OpenCode on plugin init)
 // =============================================================================
 
+/**
+ * Project info as provided by OpenCode.
+ *
+ * Mirrors the Project.Info shape from sst/opencode:
+ *   packages/opencode/src/project/project.ts
+ *
+ * Key fields:
+ *   - id:        root commit hash (or "global" for non-git)
+ *   - worktree:  dirname(git rev-parse --git-common-dir) — main repo root
+ *   - vcs:       "git" | undefined
+ *   - sandboxes: list of active sandboxes / worktrees
+ */
+export interface OpenCodeProject {
+  id: string;
+  /** Main repository root (git common dir parent). NOT the sandbox/worktree. */
+  worktree: string;
+  /** Version control system type */
+  vcs?: string;
+  /** Optional display name */
+  name?: string;
+  /** Optional icon */
+  icon?: string;
+  /** Active sandboxes (worktree paths) */
+  sandboxes?: string[];
+  /** Timestamps */
+  time?: { created: number; updated: number };
+  /** Allow additional fields from future OpenCode versions */
+  [key: string]: unknown;
+}
+
 export interface PluginInput {
   /** OpenCode SDK client for API interactions */
   client: OpenCodeClient;
-  /** Current project information */
-  project: { name?: string; directory?: string };
-  /** Current working directory */
+  /**
+   * Current project information.
+   *
+   * NOTE: This is a full Project.Info from OpenCode, NOT a minimal
+   * { name, directory } object. The key field for project root is
+   * `project.worktree` (the git common dir parent), not
+   * `project.directory` (which does not exist in OpenCode's type).
+   */
+  project: OpenCodeProject;
+  /**
+   * The directory OpenCode was invoked from.
+   * Typically process.cwd() or the --dir argument.
+   */
   directory: string;
-  /** Git worktree root */
+  /**
+   * Git sandbox / working tree root.
+   * Result of `git rev-parse --show-toplevel` from the cwd.
+   * For non-git projects this is "/".
+   */
   worktree: string;
   /** URL of the running OpenCode server */
   serverUrl: URL;