@jmylchreest/aide-plugin 0.0.54 → 0.0.56

package/src/opencode/hooks.ts

@@ -25,7 +25,8 @@
  *   Stop (blocking)            → session.idle re-prompts via session.prompt() for persistence
  */
 
-import { execFileSync, execSync } from "child_process";
+import { execFileSync } from "child_process";
+import which from "which";
 import { join } from "path";
 import { findAideBinary } from "../core/aide-client.js";
 import {
@@ -48,6 +49,8 @@ import { trackToolUse, updateToolStats } from "../core/tool-tracking.js";
 import { evaluateToolUse, isToolDenied } from "../core/tool-enforcement.js";
 import { checkPersistence, getActiveMode } from "../core/persistence-logic.js";
 import { checkWriteGuard } from "../core/write-guard.js";
+import { checkSmartReadHint } from "../core/context-guard.js";
+import { recordFileRead } from "../core/read-tracking.js";
 import {
   checkComments,
   getCheckableFilePath,
@@ -226,18 +229,9 @@ function createConfigHandler(
         }
         // Skip skills requiring binaries not on PATH
         if (skill.requires_binary && skill.requires_binary.length > 0) {
-          const allPresent = skill.requires_binary.every((bin) => {
-            try {
-              const cmd =
-                process.platform === "win32"
-                  ? `where ${bin}`
-                  : `command -v ${bin}`;
-              execSync(cmd, { stdio: "ignore", timeout: 2000 });
-              return true;
-            } catch {
-              return false;
-            }
-          });
+          const allPresent = skill.requires_binary.every(
+            (bin) => which.sync(bin, { nothrow: true }) !== null,
+          );
           if (!allPresent) continue;
         }
         const commandName = `aide:${skill.name}`;
@@ -730,6 +724,21 @@ function createToolBeforeHandler(
       debug(SOURCE, `Tool enforcement check failed (non-fatal): ${err}`);
     }
 
+    // Smart read hint: suggest code index for re-reads of unchanged files
+    try {
+      const hintResult = checkSmartReadHint(
+        input.tool,
+        (_output.args || {}) as Record<string, unknown>,
+        state.cwd,
+        state.binary,
+      );
+      if (hintResult.shouldHint && hintResult.hint) {
+        debug(SOURCE, `Smart read hint for ${input.tool}: ${hintResult.hint}`);
+      }
+    } catch (err) {
+      debug(SOURCE, `Smart read hint check failed (non-fatal): ${err}`);
+    }
+
     // Track tool use
     if (!state.binary) return;
 
@@ -773,6 +782,27 @@ function createToolAfterHandler(
       debug(SOURCE, `Partial memory write failed (non-fatal): ${err}`);
     }
 
+    // Record file reads for smart-read-hint feature
+    try {
+      const toolArgs = (_output.metadata?.args || {}) as Record<
+        string,
+        unknown
+      >;
+      if (
+        input.tool.toLowerCase() === "read" &&
+        toolArgs.file_path &&
+        state.binary
+      ) {
+        recordFileRead(
+          state.binary,
+          state.cwd,
+          toolArgs.file_path as string,
+        );
+      }
+    } catch (err) {
+      debug(SOURCE, `Read tracking failed (non-fatal): ${err}`);
+    }
+
     // Context pruning: dedup/supersede/purge tool outputs
     try {
       const toolArgs = (_output.metadata?.args || {}) as Record<

package/src/opencode/index.ts

@@ -40,6 +40,7 @@ import { basename, 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 type { Plugin, PluginInput, Hooks } from "./types.js";
 
 // Resolve the plugin package root so we can find bundled skills.
@@ -218,7 +219,7 @@ export const AidePlugin: Plugin = async (ctx: PluginInput): Promise<Hooks> => {
   }
 
   // Also log to stderr when debugging
-  if (process.env.AIDE_DEBUG === "1") console.error(rawLog);
+  if (isDebugEnabled()) console.error(rawLog);
 
   const resolved = resolveProjectRoot(ctx);
 
@@ -231,7 +232,7 @@ export const AidePlugin: Plugin = async (ctx: PluginInput): Promise<Hooks> => {
   } catch {
     // non-fatal
   }
-  if (process.env.AIDE_DEBUG === "1") console.error(resolvedLog);
+  if (isDebugEnabled()) console.error(resolvedLog);
 
   return createHooks(resolved.root, ctx.worktree, ctx.client, pluginRoot, {
     skipInit: !resolved.hasProjectRoot,

package/bin/aide-wrapper.sh

@@ -1,159 +0,0 @@
-#!/bin/bash
-# aide-wrapper.sh - Ensures aide binary exists before executing
-#
-# This wrapper is called by an assistant's MCP server configuration.
-# It finds the aide binary, downloads it if missing, then delegates to it.
-#
-# Plugin root resolution order:
-#   1. AIDE_PLUGIN_ROOT  (canonical, platform-agnostic)
-#   2. CLAUDE_PLUGIN_ROOT (set by Claude Code)
-#   3. SCRIPT_DIR/..      (fallback: infer from wrapper location)
-#
-# Lives at: <plugin-root>/bin/aide-wrapper.sh
-# Binary at: <plugin-root>/bin/aide
-#
-# Logs written to: .aide/_logs/wrapper.log
-
-set -eo pipefail
-
-# Resolve symlinks so that invoking via node_modules/.bin/aide-wrapper
-# (which is a symlink to the real package) gives us the real package dir.
-REAL_SCRIPT="$(readlink -f "$0" 2>/dev/null || realpath "$0" 2>/dev/null || echo "$0")"
-SCRIPT_DIR="$(cd "$(dirname "$REAL_SCRIPT")" && pwd)"
-PLUGIN_ROOT="${AIDE_PLUGIN_ROOT:-${CLAUDE_PLUGIN_ROOT:-$(cd "$SCRIPT_DIR/.." && pwd)}}"
-
-# Binary extension
-EXT=""
-if [[ "$OSTYPE" == "msys" || "$OSTYPE" == "cygwin" || "$OSTYPE" == "win32" ]]; then
-  EXT=".exe"
-fi
-
-BINARY="$PLUGIN_ROOT/bin/aide${EXT}"
-BIN_DIR="$PLUGIN_ROOT/bin"
-
-# Setup logging
-LOG_DIR="$PLUGIN_ROOT/.aide/_logs"
-LOG_FILE="$LOG_DIR/wrapper.log"
-mkdir -p "$LOG_DIR" 2>/dev/null || true
-
-log() {
-  local timestamp
-  timestamp="$(date '+%Y-%m-%d %H:%M:%S')"
-  local msg="[$timestamp] [aide-wrapper] $*"
-  echo "$msg" >&2
-  echo "$msg" >> "$LOG_FILE" 2>/dev/null || true
-}
-
-PARENT_PID=$PPID
-PARENT_CMD=$(ps -o comm= -p "$PPID" 2>/dev/null || echo "unknown")
-PARENT_ARGS=$(ps -o args= -p "$PPID" 2>/dev/null || echo "unknown")
-log "Starting wrapper (pid=$$, ppid=$PARENT_PID, parent=$PARENT_CMD, parent_args=$PARENT_ARGS, args=$*)"
-log "PLUGIN_ROOT=$PLUGIN_ROOT"
-log "BINARY=$BINARY"
-
-# Version comparison: returns 0 (true) if $1 >= $2 (semver base only)
-version_gte() {
-  local IFS=.
-  local a=($1) b=($2)
-  for i in 0 1 2; do
-    local va=${a[$i]:-0} vb=${b[$i]:-0}
-    if (( va > vb )); then return 0; fi
-    if (( va < vb )); then return 1; fi
-  done
-  return 0
-}
-
-# Determine if we need to download
-NEEDS_DOWNLOAD=false
-
-if [[ ! -x "$BINARY" ]]; then
-  NEEDS_DOWNLOAD=true
-  log "Binary not found or not executable"
-else
-  # Check if this is a dev build that should be preserved
-  BINARY_VERSION=$("$BINARY" version 2>/dev/null | grep -oE '[0-9]+\.[0-9]+\.[0-9]+(-[a-zA-Z0-9.+]+)?' | head -1 || true)
-  log "Binary version: ${BINARY_VERSION:-unknown}"
-
-  if [[ -n "$BINARY_VERSION" && "$BINARY_VERSION" == *"-dev."* ]]; then
-    # Dev build — check base version against plugin version
-    BASE_VERSION="${BINARY_VERSION%%-*}"
-    # Read plugin version: try .claude-plugin/plugin.json (dev), fall back to package.json (npm)
-    PLUGIN_VERSION=$(grep -oP '"version"\s*:\s*"\K[0-9]+\.[0-9]+\.[0-9]+' "$PLUGIN_ROOT/.claude-plugin/plugin.json" 2>/dev/null \
-      || grep -oP '"version"\s*:\s*"\K[0-9]+\.[0-9]+\.[0-9]+' "$PLUGIN_ROOT/package.json" 2>/dev/null \
-      || true)
-
-    if [[ -n "$PLUGIN_VERSION" ]] && version_gte "$BASE_VERSION" "$PLUGIN_VERSION"; then
-      log "Dev build v$BINARY_VERSION (base $BASE_VERSION >= plugin v$PLUGIN_VERSION), using local build"
-    else
-      NEEDS_DOWNLOAD=true
-      log "Dev build v$BINARY_VERSION is older than plugin v${PLUGIN_VERSION:-unknown}, re-downloading"
-    fi
-  else
-    log "Release binary v${BINARY_VERSION:-unknown}"
-  fi
-fi
-
-if [[ "$NEEDS_DOWNLOAD" == "true" ]]; then
-  LOCKFILE="$BIN_DIR/.aide-download.lock"
-
-  # Resolve the downloader script — prefer src/ (dev) but fall back to dist/ (npm install)
-  if [[ -f "$PLUGIN_ROOT/src/lib/aide-downloader.ts" ]]; then
-    DOWNLOADER="$PLUGIN_ROOT/src/lib/aide-downloader.ts"
-  elif [[ -f "$PLUGIN_ROOT/dist/lib/aide-downloader.js" ]]; then
-    DOWNLOADER="$PLUGIN_ROOT/dist/lib/aide-downloader.js"
-  else
-    log "ERROR: Cannot find aide-downloader in src/ or dist/ under $PLUGIN_ROOT"
-    exit 1
-  fi
-
-  # Remove the stale/outdated binary before entering the lock so that
-  # the re-check inside the critical section can distinguish between
-  # "no binary yet" and "a concurrent process just downloaded the right one".
-  if [[ -f "$BINARY" ]]; then
-    log "Removing outdated binary before download"
-    rm -f "$BINARY" 2>/dev/null || true
-  fi
-
-  # Use flock to ensure only one process downloads at a time.
-  # If another process holds the lock, we wait for it to finish.
-  (
-    flock -w 60 9 || { log "ERROR: Timed out waiting for download lock"; exit 1; }
-
-    # Re-check after acquiring lock — another process may have finished the download
-    if [[ -x "$BINARY" ]]; then
-      log "Binary appeared while waiting for lock (downloaded by another process)"
-    else
-      log "Downloading binary..."
-      log "Using downloader: $DOWNLOADER"
-
-      # Use bun/tsx for .ts files (dev), node for .js files (npm install)
-      if [[ "$DOWNLOADER" == *.ts ]]; then
-        if command -v bun &>/dev/null; then
-          RUNNER="bun"
-        elif command -v tsx &>/dev/null; then
-          RUNNER="tsx"
-        else
-          RUNNER="npx --yes tsx"
-        fi
-      else
-        RUNNER="node"
-      fi
-
-      if ! $RUNNER "$DOWNLOADER" --dest "$BIN_DIR" 2>&1 | tee -a "$LOG_FILE" >&2; then
-        log "ERROR: Downloader failed"
-        exit 1
-      fi
-
-      if [[ ! -x "$BINARY" ]]; then
-        log "ERROR: Binary not found after download"
-        exit 1
-      fi
-    fi
-  ) 9>"$LOCKFILE"
-
-  rm -f "$LOCKFILE"
-  log "Binary ready at $BINARY"
-fi
-
-log "Executing: $BINARY $*"
-exec "$BINARY" "$@"

package/src/lib/skills-registry.ts

@@ -1,362 +0,0 @@
-/**
- * Skills Registry (skills.sh integration)
- *
- * STATUS: UTILITY LIBRARY - Not yet integrated into hooks
- *
- * This library provides programmatic management of skills from the skills.sh
- * marketplace. Skills are markdown files with YAML frontmatter that define
- * triggers and behaviors for the skill-injector hook.
- *
- * Currently, skill discovery and loading is done directly in skill-injector.ts.
- * This registry library is intended for future use cases:
- *
- * Future integration:
- * - CLI commands for `aide skill install/uninstall/update`
- * - Automatic skill updates on session start
- * - Skill marketplace browsing and search
- *
- * The skill-injector hook currently handles skill discovery inline because:
- * 1. It only needs to read local skill files, not manage them
- * 2. It needs to be fast (runs on every user prompt)
- * 3. Registry features (install, update) are not needed at runtime
- */
-
-import { execFileSync } from "child_process";
-import {
-  existsSync,
-  readFileSync,
-  writeFileSync,
-  mkdirSync,
-  readdirSync,
-  copyFileSync,
-  unlinkSync,
-} from "fs";
-import { join, basename, resolve } from "path";
-import { homedir } from "os";
-
-export interface SkillMetadata {
-  name: string;
-  version: string;
-  source: string;
-  installedAt: string;
-  updatedAt?: string;
-}
-
-export interface SkillsRegistry {
-  installed: SkillMetadata[];
-  autoUpdate: boolean;
-  syncInterval: string;
-  lastSync?: string;
-}
-
-const REGISTRY_FILE = ".aide/skills/registry.json";
-const SKILLS_DIR = ".aide/skills";
-const GLOBAL_SKILLS_DIR = join(homedir(), ".aide", "skills");
-
-/**
- * Validate and sanitize a URL for safe fetching
- * Prevents command injection by ensuring only valid http/https URLs
- */
-function validateUrl(url: string): string | null {
-  try {
-    const parsed = new URL(url);
-    if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
-      return null;
-    }
-    // Return the properly parsed URL (sanitized)
-    return parsed.toString();
-  } catch {
-    return null;
-  }
-}
-
-/**
- * Safely fetch content from a URL using curl
- * Uses execFileSync with argument array to prevent command injection
- */
-function safeFetch(url: string): string | null {
-  const validUrl = validateUrl(url);
-  if (!validUrl) {
-    console.error(`Invalid URL: ${url}`);
-    return null;
-  }
-  try {
-    return execFileSync("curl", ["-sL", validUrl], {
-      encoding: "utf-8",
-      timeout: 30000,
-    });
-  } catch (error) {
-    console.error(`Failed to fetch ${validUrl}: ${error}`);
-    return null;
-  }
-}
-
-/**
- * Load skills registry
- */
-export function loadRegistry(cwd: string): SkillsRegistry {
-  const registryPath = join(cwd, REGISTRY_FILE);
-  if (existsSync(registryPath)) {
-    try {
-      return JSON.parse(readFileSync(registryPath, "utf-8"));
-    } catch {
-      // Return default
-    }
-  }
-  return {
-    installed: [],
-    autoUpdate: true,
-    syncInterval: "24h",
-  };
-}
-
-/**
- * Save skills registry
- */
-export function saveRegistry(cwd: string, registry: SkillsRegistry): void {
-  const skillsDir = join(cwd, SKILLS_DIR);
-  if (!existsSync(skillsDir)) {
-    mkdirSync(skillsDir, { recursive: true });
-  }
-  writeFileSync(join(cwd, REGISTRY_FILE), JSON.stringify(registry, null, 2));
-}
-
-/**
- * Sanitize a skill name to prevent path traversal.
- * Strips path separators and rejects names that would escape the target directory.
- */
-function sanitizeSkillName(name: string): string {
-  // Take only the basename to strip any directory components
-  const safe = basename(name).replace(/[^a-zA-Z0-9._-]/g, "_");
-  if (!safe || safe === "." || safe === "..") {
-    throw new Error(`Invalid skill name: ${name}`);
-  }
-  return safe;
-}
-
-/**
- * Validate that a resolved path stays within the expected directory.
- */
-function assertWithinDir(filePath: string, dir: string): void {
-  const resolved = resolve(filePath);
-  const resolvedDir = resolve(dir);
-  if (!resolved.startsWith(resolvedDir + "/") && resolved !== resolvedDir) {
-    throw new Error(`Path traversal detected: ${filePath} escapes ${dir}`);
-  }
-}
-
-/**
- * Install a skill from skills.sh or a URL
- *
- * Formats:
- *   - skills.sh/<author>/<skill>
- *   - https://github.com/<owner>/<repo>/blob/main/<path>.md
- *   - Local file path
- */
-export async function installSkill(
-  cwd: string,
-  source: string,
-  options: { global?: boolean } = {},
-): Promise<SkillMetadata | null> {
-  const targetDir = options.global ? GLOBAL_SKILLS_DIR : join(cwd, SKILLS_DIR);
-
-  // Ensure target directory exists
-  if (!existsSync(targetDir)) {
-    mkdirSync(targetDir, { recursive: true });
-  }
-
-  let content: string;
-  let name: string;
-  let version = "1.0.0";
-
-  // Handle different source formats
-  if (
-    source.startsWith("skills.sh/") ||
-    source.startsWith("https://skills.sh/")
-  ) {
-    // skills.sh marketplace format: skills.sh/author/skill
-    const skillPath = source
-      .replace("skills.sh/", "")
-      .replace("https://skills.sh/", "");
-    const url = `https://skills.sh/api/skills/${skillPath}/raw`;
-
-    const fetched = safeFetch(url);
-    if (!fetched) {
-      console.error(`Failed to fetch skill from skills.sh`);
-      return null;
-    }
-    content = fetched;
-    name = skillPath.split("/").pop() || "unknown";
-  } else if (source.startsWith("https://github.com/")) {
-    // GitHub raw file
-    const rawUrl = source
-      .replace("github.com", "raw.githubusercontent.com")
-      .replace("/blob/", "/");
-
-    const fetched = safeFetch(rawUrl);
-    if (!fetched) {
-      console.error(`Failed to fetch skill from GitHub`);
-      return null;
-    }
-    content = fetched;
-    name = basename(source, ".md");
-  } else if (source.startsWith("https://") || source.startsWith("http://")) {
-    // Direct URL
-    const fetched = safeFetch(source);
-    if (!fetched) {
-      console.error(`Failed to fetch skill`);
-      return null;
-    }
-    content = fetched;
-    name = basename(source, ".md");
-  } else if (existsSync(source)) {
-    // Local file
-    content = readFileSync(source, "utf-8");
-    name = basename(source, ".md");
-  } else {
-    console.error(`Invalid skill source: ${source}`);
-    return null;
-  }
-
-  // Parse skill to extract metadata
-  const meta = parseSkillFrontmatter(content);
-  if (meta) {
-    name = meta.name || name;
-    version = meta.version || version;
-  }
-
-  // Sanitize name and write skill file
-  name = sanitizeSkillName(name);
-  const skillPath = join(targetDir, `${name}.md`);
-  assertWithinDir(skillPath, targetDir);
-  writeFileSync(skillPath, content);
-
-  // Update registry
-  const registry = loadRegistry(cwd);
-  const existing = registry.installed.findIndex((s) => s.name === name);
-
-  const metadata: SkillMetadata = {
-    name,
-    version,
-    source,
-    installedAt: new Date().toISOString(),
-  };
-
-  if (existing >= 0) {
-    metadata.installedAt = registry.installed[existing].installedAt;
-    metadata.updatedAt = new Date().toISOString();
-    registry.installed[existing] = metadata;
-  } else {
-    registry.installed.push(metadata);
-  }
-
-  saveRegistry(cwd, registry);
-
-  console.log(`Installed skill: ${name} (${version})`);
-  return metadata;
-}
-
-/**
- * Uninstall a skill
- */
-export function uninstallSkill(cwd: string, name: string): boolean {
-  const registry = loadRegistry(cwd);
-  const index = registry.installed.findIndex((s) => s.name === name);
-
-  if (index < 0) {
-    console.error(`Skill not installed: ${name}`);
-    return false;
-  }
-
-  // Sanitize name and remove file
-  const safeName = sanitizeSkillName(name);
-  const skillPath = join(cwd, SKILLS_DIR, `${safeName}.md`);
-  assertWithinDir(skillPath, join(cwd, SKILLS_DIR));
-  if (existsSync(skillPath)) {
-    try {
-      unlinkSync(skillPath);
-    } catch {
-      // Ignore
-    }
-  }
-
-  // Update registry
-  registry.installed.splice(index, 1);
-  saveRegistry(cwd, registry);
-
-  console.log(`Uninstalled skill: ${name}`);
-  return true;
-}
-
-/**
- * List installed skills
- */
-export function listSkills(cwd: string): SkillMetadata[] {
-  const registry = loadRegistry(cwd);
-  return registry.installed;
-}
-
-/**
- * Update all skills (if autoUpdate is enabled)
- */
-export async function updateSkills(cwd: string): Promise<void> {
-  const registry = loadRegistry(cwd);
-
-  if (!registry.autoUpdate) {
-    console.log("Auto-update is disabled");
-    return;
-  }
-
-  console.log("Updating skills...");
-
-  for (const skill of registry.installed) {
-    if (
-      skill.source.startsWith("skills.sh/") ||
-      skill.source.startsWith("https://")
-    ) {
-      await installSkill(cwd, skill.source);
-    }
-  }
-
-  registry.lastSync = new Date().toISOString();
-  saveRegistry(cwd, registry);
-
-  console.log("Skills updated");
-}
-
-/**
- * Search for skills (placeholder - would query skills.sh API)
- */
-export async function searchSkills(
-  query: string,
-): Promise<Array<{ name: string; description: string; author: string }>> {
-  // In a real implementation, this would query the skills.sh API
-  console.log(`Searching for skills matching: ${query}`);
-  console.log("Note: skills.sh integration requires API access");
-
-  return [];
-}
-
-/**
- * Parse YAML frontmatter from skill content
- */
-function parseSkillFrontmatter(
-  content: string,
-): { name?: string; version?: string; description?: string } | null {
-  const match = content.match(/^---\r?\n([\s\S]*?)\r?\n---/);
-  if (!match) return null;
-
-  const yaml = match[1];
-  const result: { name?: string; version?: string; description?: string } = {};
-
-  const nameMatch = yaml.match(/^name:\s*(.+)$/m);
-  if (nameMatch) result.name = nameMatch[1].trim();
-
-  const versionMatch = yaml.match(/^version:\s*(.+)$/m);
-  if (versionMatch) result.version = versionMatch[1].trim();
-
-  const descMatch = yaml.match(/^description:\s*(.+)$/m);
-  if (descMatch) result.description = descMatch[1].trim();
-
-  return result;
-}