@jmylchreest/aide-plugin 0.0.19 → 0.0.22

package/package.json

@@ -1,38 +1,31 @@
 {
   "name": "@jmylchreest/aide-plugin",
-  "version": "0.0.19",
+  "version": "0.0.22",
   "description": "aide plugin for OpenCode — multi-agent orchestration, memory, skills, and persistence",
   "type": "module",
-  "main": "./dist/opencode/index.js",
-  "types": "./dist/opencode/index.d.ts",
+  "main": "./src/opencode/index.ts",
   "exports": {
     ".": {
-      "import": "./dist/opencode/index.js",
-      "types": "./dist/opencode/index.d.ts"
+      "import": "./src/opencode/index.ts"
     }
   },
   "files": [
-    "dist/opencode",
-    "dist/core",
-    "dist/cli",
-    "dist/lib/aide-downloader.js",
-    "dist/lib/aide-downloader.js.map",
-    "dist/lib/aide-downloader.d.ts",
-    "dist/lib/hook-utils.js",
-    "dist/lib/hook-utils.js.map",
-    "dist/lib/hook-utils.d.ts",
+    "src/opencode",
+    "src/core",
+    "src/cli",
+    "src/lib",
     "bin",
     "README.md"
   ],
   "bin": {
-    "aide-plugin": "./dist/cli/index.js",
+    "aide-plugin": "./src/cli/index.ts",
     "aide-wrapper": "./bin/aide-wrapper.sh"
   },
   "scripts": {
-    "prebuild": "npm run copy-dist",
-    "build": "echo 'Build uses root project dist/ output'",
-    "copy-dist": "node scripts/copy-dist.mjs",
-    "prepublishOnly": "npm run copy-dist"
+    "prebuild": "npm run copy-src",
+    "build": "echo 'Ships TypeScript source — no compilation needed'",
+    "copy-src": "node scripts/copy-src.mjs",
+    "prepublishOnly": "npm run copy-src"
   },
   "keywords": [
     "aide",
@@ -52,7 +45,7 @@
     "directory": "packages/opencode-plugin"
   },
   "engines": {
-    "node": ">=20.0.0"
+    "bun": ">=1.0.0"
   },
   "dependencies": {}
 }

package/src/cli/config.ts

@@ -0,0 +1,150 @@
+/**
+ * OpenCode config file utilities.
+ *
+ * Handles reading, merging, and writing opencode.json at both
+ * global (~/.config/opencode/opencode.json) and project (./opencode.json) scopes.
+ */
+
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { dirname, join } from "path";
+import { homedir } from "os";
+
+export interface McpServerConfig {
+  type?: string;
+  command?: string[];
+  environment?: Record<string, string>;
+  enabled?: boolean;
+}
+
+export interface OpenCodeConfig {
+  $schema?: string;
+  plugin?: string[];
+  mcp?: Record<string, McpServerConfig>;
+  [key: string]: unknown;
+}
+
+const PLUGIN_NAME = "@jmylchreest/aide-plugin";
+const MCP_SERVER_NAME = "aide";
+const SCHEMA_URL = "https://opencode.ai/config.json";
+
+/**
+ * Get the path to the global OpenCode config file.
+ */
+export function getGlobalConfigPath(): string {
+  return join(homedir(), ".config", "opencode", "opencode.json");
+}
+
+/**
+ * Get the path to the project-level OpenCode config file.
+ */
+export function getProjectConfigPath(): string {
+  return join(process.cwd(), "opencode.json");
+}
+
+/**
+ * Read and parse an opencode.json file. Returns an empty config if
+ * the file doesn't exist or can't be parsed.
+ */
+export function readConfig(configPath: string): OpenCodeConfig {
+  if (!existsSync(configPath)) {
+    return {};
+  }
+  try {
+    const raw = readFileSync(configPath, "utf-8");
+    return JSON.parse(raw) as OpenCodeConfig;
+  } catch {
+    return {};
+  }
+}
+
+/**
+ * Write a config object to an opencode.json file, creating
+ * parent directories as needed.
+ */
+export function writeConfig(configPath: string, config: OpenCodeConfig): void {
+  const dir = dirname(configPath);
+  mkdirSync(dir, { recursive: true });
+  writeFileSync(configPath, JSON.stringify(config, null, 2) + "\n");
+}
+
+/**
+ * Add the aide plugin and MCP server to a config object.
+ * Preserves all existing config keys.
+ */
+export function addAideToConfig(
+  config: OpenCodeConfig,
+  options: { noMcp?: boolean } = {},
+): OpenCodeConfig {
+  const result = { ...config };
+
+  // Ensure schema
+  if (!result.$schema) {
+    result.$schema = SCHEMA_URL;
+  }
+
+  // Add plugin to array (deduplicated)
+  const plugins = result.plugin ?? [];
+  if (!plugins.includes(PLUGIN_NAME)) {
+    plugins.push(PLUGIN_NAME);
+  }
+  result.plugin = plugins;
+
+  // Add MCP server config
+  if (!options.noMcp) {
+    const mcp = result.mcp ?? {};
+    if (!mcp[MCP_SERVER_NAME]) {
+      mcp[MCP_SERVER_NAME] = {
+        type: "local",
+        command: ["npx", "-y", "-p", PLUGIN_NAME, "aide-wrapper", "mcp"],
+        environment: {
+          AIDE_CODE_WATCH: "1",
+          AIDE_CODE_WATCH_DELAY: "30s",
+        },
+        enabled: true,
+      };
+    }
+    result.mcp = mcp;
+  }
+
+  return result;
+}
+
+/**
+ * Remove the aide plugin and MCP server from a config object.
+ */
+export function removeAideFromConfig(config: OpenCodeConfig): OpenCodeConfig {
+  const result = { ...config };
+
+  // Remove plugin from array
+  if (result.plugin) {
+    result.plugin = result.plugin.filter((p) => p !== PLUGIN_NAME);
+    if (result.plugin.length === 0) {
+      delete result.plugin;
+    }
+  }
+
+  // Remove MCP server
+  if (result.mcp) {
+    delete result.mcp[MCP_SERVER_NAME];
+    if (Object.keys(result.mcp).length === 0) {
+      delete result.mcp;
+    }
+  }
+
+  return result;
+}
+
+/**
+ * Check if aide is configured in a config object.
+ */
+export function isAideConfigured(config: OpenCodeConfig): {
+  plugin: boolean;
+  mcp: boolean;
+} {
+  return {
+    plugin: config.plugin?.includes(PLUGIN_NAME) ?? false,
+    mcp: config.mcp?.[MCP_SERVER_NAME] != null,
+  };
+}
+
+export { PLUGIN_NAME, MCP_SERVER_NAME };

package/{dist/cli/index.js → src/cli/index.ts}

@@ -1,4 +1,4 @@
-#!/usr/bin/env node
+#!/usr/bin/env bun
 /**
  * aide CLI — install/uninstall the aide plugin for OpenCode.
  *
@@ -7,13 +7,16 @@
  *   bunx @jmylchreest/aide-plugin uninstall  # Remove from OpenCode config
  *   bunx @jmylchreest/aide-plugin status     # Show current installation status
  */
+
 import { install } from "./install.js";
 import { uninstall } from "./uninstall.js";
 import { status } from "./status.js";
+
 const args = process.argv.slice(2);
 const command = args[0];
-function printUsage() {
-    console.log(`aide - AI Development Environment plugin for OpenCode
+
+function printUsage(): void {
+  console.log(`aide - AI Development Environment plugin for OpenCode
 
 Usage:
   aide-plugin install     Install aide plugin globally for OpenCode
@@ -27,39 +30,40 @@ Options:
 
 Examples:
   bunx @jmylchreest/aide-plugin install
-  npx @jmylchreest/aide-plugin install
   aide-plugin install --project`);
 }
-async function main() {
-    const flags = {
-        project: args.includes("--project"),
-        noMcp: args.includes("--no-mcp"),
-    };
-    switch (command) {
-        case "install":
-            await install(flags);
-            break;
-        case "uninstall":
-            await uninstall(flags);
-            break;
-        case "status":
-            await status();
-            break;
-        case "--help":
-        case "-h":
-        case "help":
-            printUsage();
-            break;
-        default:
-            if (command) {
-                console.error(`Unknown command: ${command}\n`);
-            }
-            printUsage();
-            process.exit(command ? 1 : 0);
-    }
+
+async function main(): Promise<void> {
+  const flags = {
+    project: args.includes("--project"),
+    noMcp: args.includes("--no-mcp"),
+  };
+
+  switch (command) {
+    case "install":
+      await install(flags);
+      break;
+    case "uninstall":
+      await uninstall(flags);
+      break;
+    case "status":
+      await status();
+      break;
+    case "--help":
+    case "-h":
+    case "help":
+      printUsage();
+      break;
+    default:
+      if (command) {
+        console.error(`Unknown command: ${command}\n`);
+      }
+      printUsage();
+      process.exit(command ? 1 : 0);
+  }
 }
+
 main().catch((err) => {
-    console.error(`Error: ${err instanceof Error ? err.message : String(err)}`);
-    process.exit(1);
+  console.error(`Error: ${err instanceof Error ? err.message : String(err)}`);
+  process.exit(1);
 });
-//# sourceMappingURL=index.js.map

package/src/cli/install.ts

@@ -0,0 +1,71 @@
+/**
+ * Install command — registers aide plugin and MCP server in OpenCode config.
+ */
+
+import {
+  addAideToConfig,
+  getGlobalConfigPath,
+  getProjectConfigPath,
+  isAideConfigured,
+  readConfig,
+  writeConfig,
+  PLUGIN_NAME,
+} from "./config.js";
+
+export interface InstallFlags {
+  project?: boolean;
+  noMcp?: boolean;
+}
+
+export async function install(flags: InstallFlags): Promise<void> {
+  const configPath = flags.project
+    ? getProjectConfigPath()
+    : getGlobalConfigPath();
+
+  const scope = flags.project ? "project" : "global";
+  console.log(`Installing aide plugin (${scope})...\n`);
+
+  // Read existing config
+  const existing = readConfig(configPath);
+  const before = isAideConfigured(existing);
+
+  if (before.plugin && before.mcp) {
+    console.log(`aide is already configured in ${configPath}`);
+    console.log("  plugin: registered");
+    console.log("  mcp:    registered");
+    console.log("\nNothing to do.");
+    return;
+  }
+
+  // Apply changes
+  const updated = addAideToConfig(existing, { noMcp: flags.noMcp });
+  writeConfig(configPath, updated);
+
+  // Report what was done
+  const after = isAideConfigured(updated);
+  console.log(`Updated: ${configPath}\n`);
+
+  if (!before.plugin && after.plugin) {
+    console.log(`  + Added "${PLUGIN_NAME}" to plugin array`);
+  } else if (before.plugin) {
+    console.log(`  = Plugin already registered`);
+  }
+
+  if (!flags.noMcp) {
+    if (!before.mcp && after.mcp) {
+      console.log(`  + Added "aide" MCP server`);
+    } else if (before.mcp) {
+      console.log(`  = MCP server already registered`);
+    }
+  } else {
+    console.log(`  - Skipped MCP server registration (--no-mcp)`);
+  }
+
+  console.log("\nInstallation complete. Start OpenCode to use aide.");
+
+  if (!flags.project) {
+    console.log(
+      "\nThe plugin is installed globally and will apply to all OpenCode projects.",
+    );
+  }
+}

package/src/cli/status.ts

@@ -0,0 +1,46 @@
+/**
+ * Status command — shows current aide installation status for OpenCode.
+ */
+
+import { existsSync } from "fs";
+import {
+  getGlobalConfigPath,
+  getProjectConfigPath,
+  isAideConfigured,
+  readConfig,
+} from "./config.js";
+
+export async function status(): Promise<void> {
+  console.log("aide plugin status\n");
+
+  const globalPath = getGlobalConfigPath();
+  const projectPath = getProjectConfigPath();
+
+  // Global config
+  console.log(`Global config: ${globalPath}`);
+  if (existsSync(globalPath)) {
+    const globalConfig = readConfig(globalPath);
+    const globalStatus = isAideConfigured(globalConfig);
+    console.log(
+      `  plugin: ${globalStatus.plugin ? "registered" : "not found"}`,
+    );
+    console.log(`  mcp:    ${globalStatus.mcp ? "registered" : "not found"}`);
+  } else {
+    console.log("  (file does not exist)");
+  }
+
+  console.log();
+
+  // Project config
+  console.log(`Project config: ${projectPath}`);
+  if (existsSync(projectPath)) {
+    const projectConfig = readConfig(projectPath);
+    const projectStatus = isAideConfigured(projectConfig);
+    console.log(
+      `  plugin: ${projectStatus.plugin ? "registered" : "not found"}`,
+    );
+    console.log(`  mcp:    ${projectStatus.mcp ? "registered" : "not found"}`);
+  } else {
+    console.log("  (file does not exist)");
+  }
+}

package/src/cli/uninstall.ts

@@ -0,0 +1,48 @@
+/**
+ * Uninstall command — removes aide plugin and MCP server from OpenCode config.
+ */
+
+import {
+  getGlobalConfigPath,
+  getProjectConfigPath,
+  isAideConfigured,
+  readConfig,
+  removeAideFromConfig,
+  writeConfig,
+} from "./config.js";
+
+export interface UninstallFlags {
+  project?: boolean;
+}
+
+export async function uninstall(flags: UninstallFlags): Promise<void> {
+  const configPath = flags.project
+    ? getProjectConfigPath()
+    : getGlobalConfigPath();
+
+  const scope = flags.project ? "project" : "global";
+  console.log(`Uninstalling aide plugin (${scope})...\n`);
+
+  const existing = readConfig(configPath);
+  const before = isAideConfigured(existing);
+
+  if (!before.plugin && !before.mcp) {
+    console.log(`aide is not configured in ${configPath}`);
+    console.log("\nNothing to do.");
+    return;
+  }
+
+  const updated = removeAideFromConfig(existing);
+  writeConfig(configPath, updated);
+
+  console.log(`Updated: ${configPath}\n`);
+
+  if (before.plugin) {
+    console.log(`  - Removed aide plugin from plugin array`);
+  }
+  if (before.mcp) {
+    console.log(`  - Removed aide MCP server`);
+  }
+
+  console.log("\nUninstallation complete.");
+}

package/src/core/aide-client.ts

@@ -0,0 +1,201 @@
+/**
+ * Platform-agnostic aide binary discovery and state operations.
+ *
+ * Extracted from src/lib/hook-utils.ts. Both Claude Code hooks and
+ * OpenCode plugin use this module for binary discovery and state management.
+ *
+ * Key difference from hook-utils.ts: accepts explicit binary path and
+ * platform-specific options instead of relying on CLAUDE_PLUGIN_ROOT.
+ */
+
+import { execSync, execFileSync } from "child_process";
+import { existsSync, realpathSync } from "fs";
+import { join } from "path";
+import type { FindBinaryOptions } from "./types.js";
+import { debug } from "../lib/logger.js";
+
+const SOURCE = "aide-client";
+
+/**
+ * Find the aide binary — platform-agnostic implementation.
+ *
+ * Search order:
+ *   1. pluginRoot/bin/aide (if pluginRoot provided)
+ *   2. cwd/.aide/bin/aide  (project-local install)
+ *   3. Each path in additionalPaths
+ *   4. PATH fallback (system-wide install)
+ */
+export function findAideBinary(opts: FindBinaryOptions = {}): string | null {
+  const { cwd, additionalPaths = [] } = opts;
+  let { pluginRoot } = opts;
+
+  // Resolve symlinks on pluginRoot
+  if (pluginRoot) {
+    try {
+      pluginRoot = realpathSync(pluginRoot);
+    } catch (err) {
+      debug(SOURCE, `realpath failed for pluginRoot ${pluginRoot}: ${err}`);
+    }
+  }
+
+  // 1. Plugin root bin/
+  if (pluginRoot) {
+    const pluginBinary = join(pluginRoot, "bin", "aide");
+    if (existsSync(pluginBinary)) {
+      return pluginBinary;
+    }
+  }
+
+  // 2. Project-local .aide/bin/
+  if (cwd) {
+    const projectBinary = join(cwd, ".aide", "bin", "aide");
+    if (existsSync(projectBinary)) {
+      return projectBinary;
+    }
+  }
+
+  // 3. Additional paths
+  for (const searchPath of additionalPaths) {
+    const binary = join(searchPath, "aide");
+    if (existsSync(binary)) {
+      return binary;
+    }
+  }
+
+  // 4. PATH fallback
+  try {
+    const result = execSync("which aide", { stdio: "pipe", timeout: 2000 })
+      .toString()
+      .trim();
+    if (result) return result;
+  } catch (err) {
+    debug(SOURCE, `aide not found in PATH: ${err}`);
+  }
+
+  return null;
+}
+
+/**
+ * Run an aide command and return stdout, or null on failure.
+ */
+export function runAide(
+  binary: string,
+  cwd: string,
+  args: string[],
+  options?: { timeout?: number; env?: Record<string, string | undefined> },
+): string | null {
+  try {
+    const env = options?.env ? { ...process.env, ...options.env } : process.env;
+    return execFileSync(binary, args, {
+      cwd,
+      encoding: "utf-8",
+      timeout: options?.timeout ?? 10000,
+      env,
+    });
+  } catch (err) {
+    debug(SOURCE, `runAide failed: ${args.join(" ")}: ${err}`);
+    return null;
+  }
+}
+
+/**
+ * Set state in aide (global or per-agent)
+ */
+export function setState(
+  binary: string,
+  cwd: string,
+  key: string,
+  value: string,
+  agentId?: string,
+): boolean {
+  try {
+    const args = ["state", "set", key, value];
+    if (agentId) args.push(`--agent=${agentId}`);
+    execFileSync(binary, args, { cwd, stdio: "pipe", timeout: 5000 });
+    return true;
+  } catch (err) {
+    debug(SOURCE, `setState failed for key=${key}: ${err}`);
+    return false;
+  }
+}
+
+/**
+ * Get state from aide
+ */
+export function getState(
+  binary: string,
+  cwd: string,
+  key: string,
+  agentId?: string,
+): string | null {
+  try {
+    const args = ["state", "get", key];
+    if (agentId) args.push(`--agent=${agentId}`);
+    const output = execFileSync(binary, args, {
+      cwd,
+      encoding: "utf-8",
+      timeout: 5000,
+    });
+    const match = output.match(/=\s*(.+)$/m);
+    return match ? match[1].trim() : null;
+  } catch (err) {
+    debug(SOURCE, `getState failed for key=${key}: ${err}`);
+    return null;
+  }
+}
+
+/**
+ * Delete a state key from aide
+ */
+export function deleteState(
+  binary: string,
+  cwd: string,
+  key: string,
+  agentId?: string,
+): boolean {
+  try {
+    const fullKey = agentId ? `agent:${agentId}:${key}` : key;
+    execFileSync(binary, ["state", "delete", fullKey], {
+      cwd,
+      stdio: "pipe",
+    });
+    return true;
+  } catch (err) {
+    debug(SOURCE, `deleteState failed for key=${key}: ${err}`);
+    return false;
+  }
+}
+
+/**
+ * Clear all state for an agent
+ */
+export function clearAgentState(
+  binary: string,
+  cwd: string,
+  agentId: string,
+): boolean {
+  try {
+    execFileSync(binary, ["state", "clear", `--agent=${agentId}`], {
+      cwd,
+      stdio: "pipe",
+    });
+    return true;
+  } catch (err) {
+    debug(SOURCE, `clearAgentState failed for agent=${agentId}: ${err}`);
+    return false;
+  }
+}
+
+/**
+ * Escape a string for safe shell usage (when shell is unavoidable)
+ */
+export function shellEscape(str: string): string {
+  return str
+    .replace(/\\/g, "\\\\")
+    .replace(/"/g, '\\"')
+    .replace(/\$/g, "\\$")
+    .replace(/`/g, "\\`")
+    .replace(/!/g, "\\!")
+    .replace(/\n/g, " ")
+    .slice(0, 1000);
+}