@jmylchreest/aide-plugin 0.0.34 → 0.0.37

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jmylchreest/aide-plugin",
-  "version": "0.0.34",
+  "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/core/mcp-sync.ts

@@ -6,7 +6,7 @@
  * back to the current assistant's config files.
  *
  * Supports:
- *   - Claude Code: ~/.mcp.json (user), .mcp.json (project)
+ *   - Claude Code: ~/.claude.json (user), .mcp.json (project) (reads legacy ~/.mcp.json)
  *   - OpenCode:    ~/.config/opencode/opencode.json (user), ./opencode.json (project)
  *   - Aide canonical: ~/.aide/config/mcp.json (user), .aide/config/mcp.json (project)
  *
@@ -43,6 +43,8 @@ export interface CanonicalMcpServer {
   name: string;
   /** "local" (stdio) or "remote" (http/sse) */
   type: "local" | "remote";
+  /** Remote transport (http/sse) */
+  transport?: "http" | "sse";
   /** Command to run (for local servers) */
   command?: string;
   /** Arguments (for local servers) */
@@ -108,14 +110,32 @@ function userJournalPath(): string {
 }
 
 /** Get all config file paths for a given assistant and scope. */
-function getAssistantPaths(
+function getAssistantReadPaths(
   platform: McpPlatform,
   scope: McpScope,
   cwd: string,
 ): string[] {
   if (platform === "claude-code") {
     return scope === "user"
-      ? [join(homedir(), ".mcp.json")]
+      ? [join(homedir(), ".claude.json"), join(homedir(), ".mcp.json")]
+      : [join(cwd, ".mcp.json")];
+  }
+  if (platform === "opencode") {
+    return scope === "user"
+      ? [join(homedir(), ".config", "opencode", "opencode.json")]
+      : [join(cwd, "opencode.json")];
+  }
+  return [];
+}
+
+function getAssistantWritePaths(
+  platform: McpPlatform,
+  scope: McpScope,
+  cwd: string,
+): string[] {
+  if (platform === "claude-code") {
+    return scope === "user"
+      ? [join(homedir(), ".claude.json")]
       : [join(cwd, ".mcp.json")];
   }
   if (platform === "opencode") {
@@ -177,12 +197,20 @@ function readClaudeConfig(path: string): Record<string, CanonicalMcpServer> {
     for (const [name, def] of Object.entries(
       (raw.mcpServers || {}) as Record<string, Record<string, unknown>>,
     )) {
-      const claudeType = (def.type as string) || "stdio";
-      const isRemote = claudeType === "sse" || !!def.url;
+      const claudeType =
+        (def.type as string) ||
+        ((def.url as string | undefined) ? "http" : "stdio");
+      const isRemote =
+        claudeType === "sse" || claudeType === "http" || !!def.url;
 
       servers[name] = {
         name,
         type: isRemote ? "remote" : "local",
+        transport: isRemote
+          ? claudeType === "sse"
+            ? "sse"
+            : "http"
+          : undefined,
         command: def.command as string | undefined,
         args: def.args as string[] | undefined,
         url: def.url as string | undefined,
@@ -236,6 +264,7 @@ function readOpenCodeConfig(path: string): Record<string, CanonicalMcpServer> {
       servers[name] = {
         name,
         type: isRemote ? "remote" : "local",
+        transport: isRemote ? "http" : undefined,
         command,
         args: args?.length ? args : undefined,
         url: def.url as string | undefined,
@@ -315,7 +344,7 @@ function writeClaudeConfig(
     const entry: Record<string, unknown> = {};
 
     if (server.type === "remote") {
-      entry.type = "sse";
+      entry.type = server.transport === "sse" ? "sse" : "http";
       if (server.url) entry.url = server.url;
       if (server.headers) entry.headers = server.headers;
     } else {
@@ -536,7 +565,7 @@ function collectServers(
 
   // Assistant configs
   for (const platform of platforms) {
-    const paths = getAssistantPaths(platform, scope, cwd);
+    const paths = getAssistantReadPaths(platform, scope, cwd);
     for (const p of paths) {
       const servers = readAssistantConfig(platform, p);
       if (Object.keys(servers).length > 0) {
@@ -630,7 +659,7 @@ function syncScope(
   }
 
   // Step 7: Write to current assistant's config
-  const assistantPaths = getAssistantPaths(platform, scope, cwd);
+  const assistantPaths = getAssistantWritePaths(platform, scope, cwd);
   for (const p of assistantPaths) {
     // Read existing assistant config to check if it needs updating
     const existingAssistant = readAssistantConfig(platform, p);

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;