@jmylchreest/aide-plugin 0.0.65 → 0.1.0

package/src/core/session-init.ts

@@ -23,9 +23,12 @@ import type {
   SessionState,
   SessionInitResult,
   MemoryInjection,
+  InjectedSource,
   StartupNotices,
 } from "./types.js";
 import { DEFAULT_CONFIG } from "./types.js";
+import { isTruthy, isFalsy } from "../lib/hook-utils.js";
+import { findProjectRoot } from "../lib/project-root.js";
 
 /**
  * Ensure all .aide directories exist
@@ -34,14 +37,19 @@ export function ensureDirectories(cwd: string): {
   created: number;
   existed: number;
 } {
+  // Resolve to the canonical project root so we don't plant a stray .aide/
+  // in a subdirectory the harness happened to launch from. When no marker
+  // is found, fall back to cwd (caller's hasMarker gate elsewhere refuses
+  // bootstrap unless AIDE_FORCE_INIT is set).
+  const { root } = findProjectRoot(cwd);
   const dirs = [
-    join(cwd, ".aide"),
-    join(cwd, ".aide", "skills"),
-    join(cwd, ".aide", "config"),
-    join(cwd, ".aide", "state"),
-    join(cwd, ".aide", "memory"),
-    join(cwd, ".aide", "worktrees"),
-    join(cwd, ".aide", "_logs"),
+    join(root, ".aide"),
+    join(root, ".aide", "skills"),
+    join(root, ".aide", "config"),
+    join(root, ".aide", "state"),
+    join(root, ".aide", "memory"),
+    join(root, ".aide", "worktrees"),
+    join(root, ".aide", "_logs"),
     join(homedir(), ".aide"),
     join(homedir(), ".aide", "skills"),
     join(homedir(), ".aide", "config"),
@@ -66,7 +74,7 @@ export function ensureDirectories(cwd: string): {
   // Ensure .gitignore exists in .aide directory.
   // Structure: exclude all local-only runtime data, allow shared/ and config/.
   // shared/ contains git-friendly markdown exports (decisions, memories).
-  const gitignorePath = join(cwd, ".aide", ".gitignore");
+  const gitignorePath = join(root, ".aide", ".gitignore");
   const requiredGitignoreContent = `# AIDE local runtime files - do not commit
 # These are machine-specific and/or binary (non-mergeable)
 _logs/
@@ -186,23 +194,40 @@ 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 { root } = findProjectRoot(cwd);
+  const projectPath = join(root, ".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;
 }
 
 /**
@@ -236,7 +261,8 @@ export function cleanupStaleStateFiles(cwd: string): {
   scanned: number;
   deleted: number;
 } {
-  const stateDir = join(cwd, ".aide", "state");
+  const { root } = findProjectRoot(cwd);
+  const stateDir = join(root, ".aide", "state");
   if (!existsSync(stateDir)) {
     return { scanned: 0, deleted: 0 };
   }
@@ -275,7 +301,8 @@ export function cleanupStaleStateFiles(cwd: string): {
  * Reset HUD state file for clean session start
  */
 export function resetHudState(cwd: string): void {
-  const hudPath = join(cwd, ".aide", "state", "hud.txt");
+  const { root } = findProjectRoot(cwd);
+  const hudPath = join(root, ".aide", "state", "hud.txt");
   try {
     if (existsSync(hudPath)) {
       writeFileSync(hudPath, "mode:idle");
@@ -303,7 +330,7 @@ export function runSessionInit(
     dynamic: { sessions: [] },
   };
 
-  if (process.env.AIDE_MEMORY_INJECT === "0") {
+  if (isFalsy(process.env.AIDE_MEMORY_INJECT)) {
     return result;
   }
 
@@ -318,7 +345,7 @@ export function runSessionInit(
     // Add --share-import if configured or env var set
     if (
       config?.share?.autoImport ||
-      process.env.AIDE_SHARE_AUTO_IMPORT === "1"
+      isTruthy(process.env.AIDE_SHARE_AUTO_IMPORT)
     ) {
       args.push("--share-import");
     }
@@ -333,7 +360,7 @@ export function runSessionInit(
 
     const data: SessionInitResult = JSON.parse(output);
 
-    if (process.env.AIDE_MEMORY_INJECT === "0") {
+    if (isFalsy(process.env.AIDE_MEMORY_INJECT)) {
       return result;
     }
 
@@ -353,6 +380,55 @@ export function runSessionInit(
         .join("\n");
       result.dynamic.sessions.push(`${header}:\n${memories}`);
     }
+
+    const sources: InjectedSource[] = [];
+    for (const m of data.global_memories) {
+      sources.push({
+        kind: "memory",
+        scope: "global",
+        id: m.id,
+        name: m.tags?.[0] ?? m.category ?? "memory",
+        content: m.content,
+        category: m.category,
+        tags: m.tags,
+        score: m.score,
+      });
+    }
+    for (const m of data.project_memories) {
+      sources.push({
+        kind: "memory",
+        scope: "project",
+        id: m.id,
+        name: m.tags?.[0] ?? m.category ?? "memory",
+        content: m.content,
+        category: m.category,
+        tags: m.tags,
+        score: m.score,
+      });
+    }
+    for (const d of data.decisions) {
+      sources.push({
+        kind: "decision",
+        scope: "project",
+        id: d.topic,
+        name: d.topic,
+        content: `${d.value}${d.rationale ? ` (${d.rationale})` : ""}`,
+      });
+    }
+    for (const sess of data.recent_sessions) {
+      for (const m of sess.memories) {
+        sources.push({
+          kind: "session_memory",
+          scope: "session",
+          id: `${sess.session_id}:${m.content.slice(0, 32)}`,
+          name: m.category || "session",
+          content: m.content,
+          category: m.category,
+          sessionId: sess.session_id,
+        });
+      }
+    }
+    result.sources = sources;
   } catch {
     // Best effort
   }

package/src/core/skill-matcher.ts

@@ -229,40 +229,36 @@ export function loadSkill(path: string): Skill | null {
 export function discoverSkills(cwd: string, pluginRoot?: string): Skill[] {
   const skills: Skill[] = [];
   const seenPaths = new Set<string>();
+  // Dedupe by skill name too — the same skill (same `name:` frontmatter)
+  // is often present in both repo/skills/ and the plugin-install
+  // skills/ dir under different file paths. Without this, matchSkills
+  // returns the same skill twice and injects it twice.
+  const seenNames = new Set<string>();
+
+  const add = (file: string) => {
+    if (seenPaths.has(file)) return;
+    seenPaths.add(file);
+    const skill = loadSkill(file);
+    if (!skill) return;
+    if (seenNames.has(skill.name)) return;
+    seenNames.add(skill.name);
+    skills.push(skill);
+  };
 
   // Project-local skills (higher priority)
   for (const location of SKILL_LOCATIONS) {
     const dir = join(cwd, location);
-    const files = findSkillFiles(dir);
-    for (const file of files) {
-      if (seenPaths.has(file)) continue;
-      seenPaths.add(file);
-      const skill = loadSkill(file);
-      if (skill) skills.push(skill);
-    }
+    for (const file of findSkillFiles(dir)) add(file);
   }
 
   // Plugin-bundled skills (if pluginRoot provided)
   if (pluginRoot) {
-    const pluginSkillDir = join(pluginRoot, "skills");
-    const files = findSkillFiles(pluginSkillDir);
-    for (const file of files) {
-      if (seenPaths.has(file)) continue;
-      seenPaths.add(file);
-      const skill = loadSkill(file);
-      if (skill) skills.push(skill);
-    }
+    for (const file of findSkillFiles(join(pluginRoot, "skills"))) add(file);
   }
 
   // Global skills (lower priority)
   for (const dir of GLOBAL_SKILL_LOCATIONS) {
-    const files = findSkillFiles(dir);
-    for (const file of files) {
-      if (seenPaths.has(file)) continue;
-      seenPaths.add(file);
-      const skill = loadSkill(file);
-      if (skill) skills.push(skill);
-    }
+    for (const file of findSkillFiles(dir)) add(file);
   }
 
   return skills;

package/src/core/tool-observe.ts

@@ -269,6 +269,18 @@ export function recordToolEvent(
     if (input.sessionId) args.push(`--session=${input.sessionId}`);
     if (startLine !== undefined) args.push(`--attr=start_line=${startLine}`);
     if (endLine !== undefined) args.push(`--attr=end_line=${endLine}`);
+    // Capture the command (Bash) or pattern (Grep) text so the repetition
+    // detector can group calls by canonical signature instead of lumping
+    // every Bash invocation under a single "Bash" bucket. Truncated to keep
+    // the attr cheap; the normaliser only uses the first token anyway.
+    const cmd = input.toolInput?.command;
+    if (typeof cmd === "string" && cmd.length > 0) {
+      args.push(`--attr=command=${cmd.slice(0, 500)}`);
+    }
+    const pattern = input.toolInput?.pattern;
+    if (typeof pattern === "string" && pattern.length > 0) {
+      args.push(`--attr=pattern=${pattern.slice(0, 200)}`);
+    }
     execFileSync(binary, args, {
       cwd,
       timeout: 3000,

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;
@@ -60,12 +70,14 @@ export interface SessionInitResult {
     content: string;
     category: string;
     tags: string[];
+    score?: number;
   }>;
   project_memories: Array<{
     id: string;
     content: string;
     category: string;
     tags: string[];
+    score?: number;
   }>;
   project_memory_overflow?: boolean;
   decisions: Array<{ topic: string; value: string; rationale?: string }>;
@@ -80,6 +92,18 @@ export interface SessionInitResult {
 // Memory Injection
 // =============================================================================
 
+export interface InjectedSource {
+  kind: "memory" | "decision" | "session_memory";
+  scope: "global" | "project" | "session";
+  id: string;
+  name: string;
+  content: string;
+  category?: string;
+  tags?: string[];
+  sessionId?: string;
+  score?: number;
+}
+
 export interface MemoryInjection {
   static: {
     global: string[];
@@ -90,6 +114,7 @@ export interface MemoryInjection {
   dynamic: {
     sessions: string[];
   };
+  sources?: InjectedSource[];
 }
 
 // =============================================================================

package/src/hooks/agent-cleanup.ts

@@ -14,6 +14,7 @@ import { readStdin } from "../lib/hook-utils.js";
 import { findAideBinary } from "../core/aide-client.js";
 import { cleanupAgent } from "../core/cleanup.js";
 import { debug } from "../lib/logger.js";
+import { findProjectRoot } from "../lib/project-root.js";
 
 const SOURCE = "agent-cleanup";
 
@@ -48,7 +49,8 @@ async function main(): Promise<void> {
       if (binary) {
         const cleared = cleanupAgent(binary, cwd, agentId);
         if (cleared) {
-          const logDir = join(cwd, ".aide", "_logs");
+          const { root } = findProjectRoot(cwd);
+          const logDir = join(root, ".aide", "_logs");
           if (existsSync(logDir)) {
             const logPath = join(logDir, "agent-cleanup.log");
             const timestamp = new Date().toISOString();

package/src/hooks/agent-signals.ts

@@ -0,0 +1,249 @@
+#!/usr/bin/env node
+/**
+ * Agent Signals Hook (PreToolUse)
+ *
+ * Fires before every tool call. In subagent contexts (session has a parent
+ * recorded by SubagentStart) it checks for halt/pause flags and unread
+ * high-priority messages, blocking or injecting context accordingly.
+ *
+ * In orchestrator / solo sessions this hook is a no-op — gated on the
+ * session having a registered parent. Cost when gated out: one cheap
+ * `aide agent identify` call (~10ms).
+ */
+
+import { execFileSync } from "child_process";
+import { Logger } from "../lib/logger.js";
+import { readStdin } from "../lib/hook-utils.js";
+import { findAideBinary } from "../core/aide-client.js";
+import { emitInjectionEvent } from "../core/read-tracking.js";
+
+const SOURCE = "agent-signals";
+
+interface PreToolUseInput {
+  hook_event_name: "PreToolUse";
+  session_id: string;
+  tool_name: string;
+  cwd: string;
+}
+
+interface HookOutput {
+  continue: boolean;
+  message?: string;
+  hookSpecificOutput?: {
+    hookEventName: string;
+    additionalContext?: string;
+  };
+}
+
+interface SignalsResponse {
+  agent: string;
+  halt?: boolean;
+  paused?: boolean;
+  reason?: string;
+  deadline?: string;
+  deadline_remaining_sec?: number;
+  high_priority_messages?: Array<{
+    id: number;
+    from: string;
+    content: string;
+    type?: string;
+  }>;
+}
+
+let log: Logger | null = null;
+
+function passThrough(): void {
+  console.log(JSON.stringify({ continue: true }));
+}
+
+function block(message: string): void {
+  const out: HookOutput = { continue: false, message };
+  console.log(JSON.stringify(out));
+}
+
+function injectContext(context: string): void {
+  const out: HookOutput = {
+    continue: true,
+    hookSpecificOutput: {
+      hookEventName: "PreToolUse",
+      additionalContext: context,
+    },
+  };
+  console.log(JSON.stringify(out));
+}
+
+function runAide(binary: string, cwd: string, args: string[]): string | null {
+  try {
+    return execFileSync(binary, args, {
+      cwd,
+      stdio: ["pipe", "pipe", "pipe"],
+      timeout: 2000,
+    }).toString();
+  } catch (err) {
+    log?.debug(`aide ${args.join(" ")} failed: ${err}`);
+    return null;
+  }
+}
+
+// Tools the subagent is still allowed to call while paused — limited to
+// communication primitives so it can report back / receive instruction.
+const PAUSE_ALLOWLIST = new Set([
+  "mcp__plugin_aide_aide__message_send",
+  "mcp__plugin_aide_aide__message_list",
+  "mcp__plugin_aide_aide__message_ack",
+  "mcp__plugin_aide_aide__state_get",
+]);
+
+async function main(): Promise<void> {
+  try {
+    const raw = await readStdin();
+    if (!raw.trim()) {
+      passThrough();
+      return;
+    }
+    const data: PreToolUseInput = JSON.parse(raw);
+    const cwd = data.cwd || process.cwd();
+    log = new Logger("agent-signals", cwd);
+
+    const binary = findAideBinary({
+      cwd,
+      pluginRoot:
+        process.env.AIDE_PLUGIN_ROOT || process.env.CLAUDE_PLUGIN_ROOT,
+    });
+    if (!binary) {
+      passThrough();
+      return;
+    }
+
+    // Gate: is this session a registered subagent? identify returns JSON
+    // with parent_session if and only if SubagentStart recorded one.
+    const idRaw = runAide(binary, cwd, [
+      "agent",
+      "identify",
+      `--agent=${data.session_id}`,
+    ]);
+    if (!idRaw) {
+      passThrough();
+      return;
+    }
+    let identity: Record<string, string>;
+    try {
+      identity = JSON.parse(idRaw);
+    } catch {
+      passThrough();
+      return;
+    }
+    if (!identity.parent_session) {
+      // Not a subagent — orchestrator/solo session. No-op.
+      passThrough();
+      return;
+    }
+
+    // Pull signal snapshot.
+    const sigRaw = runAide(binary, cwd, [
+      "agent",
+      "signals",
+      `--agent=${data.session_id}`,
+    ]);
+    if (!sigRaw) {
+      passThrough();
+      return;
+    }
+    let sig: SignalsResponse;
+    try {
+      sig = JSON.parse(sigRaw);
+    } catch {
+      passThrough();
+      return;
+    }
+
+    // 1. Halt — hard stop with reason surfaced to model.
+    if (sig.halt) {
+      const reason = sig.reason || "halted by orchestrator";
+      log?.info(`halt active for ${data.session_id}: ${reason}`);
+      block(
+        `[aide] This subagent has been halted by the orchestrator. Reason: ${reason}\n` +
+          `Stop work. You may still send a final status message via aide message send --to=<orchestrator>.`,
+      );
+      return;
+    }
+
+    // 2. Pause — block all tools except the comm allowlist.
+    if (sig.paused && !PAUSE_ALLOWLIST.has(data.tool_name)) {
+      log?.info(`paused — blocking ${data.tool_name}`);
+      block(
+        `[aide] This subagent is paused by the orchestrator. Only messaging tools are allowed until resumed.`,
+      );
+      return;
+    }
+
+    // 3. Deadline approaching — inject warning at < 20% remaining.
+    let deadlineWarn = "";
+    if (sig.deadline_remaining_sec !== undefined) {
+      if (sig.deadline_remaining_sec <= 0) {
+        block(
+          `[aide] Soft deadline reached (${sig.deadline}). Halting per orchestrator policy.`,
+        );
+        return;
+      }
+      if (sig.deadline_remaining_sec < 60 * 5) {
+        deadlineWarn = `[aide] Deadline ${sig.deadline} — ~${sig.deadline_remaining_sec}s remaining.`;
+      }
+    }
+
+    // 4. High-priority messages — inject + ack so we don't re-inject next call.
+    const parts: string[] = [];
+    if (deadlineWarn) parts.push(deadlineWarn);
+    if (sig.high_priority_messages && sig.high_priority_messages.length > 0) {
+      parts.push("[aide] Mid-flight messages from orchestrator:");
+      for (const m of sig.high_priority_messages) {
+        parts.push(`- (${m.from}${m.type ? `, ${m.type}` : ""}): ${m.content}`);
+        runAide(binary, cwd, [
+          "message",
+          "ack",
+          String(m.id),
+          `--agent=${data.session_id}`,
+        ]);
+      }
+    }
+
+    if (parts.length > 0) {
+      const ctx = parts.join("\n");
+      try {
+        emitInjectionEvent(binary, cwd, {
+          source: SOURCE,
+          subtype: "signal",
+          content: ctx,
+          sessionId: data.session_id,
+          attrs: {
+            tool: data.tool_name,
+            ...(sig.deadline ? { deadline: sig.deadline } : {}),
+            high_priority_messages: String(
+              sig.high_priority_messages?.length ?? 0,
+            ),
+          },
+        });
+      } catch {
+        // Non-fatal
+      }
+      injectContext(ctx);
+      return;
+    }
+
+    passThrough();
+  } catch (err) {
+    log?.error(`agent-signals failed: ${err}`);
+    passThrough();
+  }
+}
+
+process.on("uncaughtException", () => {
+  passThrough();
+  process.exit(0);
+});
+process.on("unhandledRejection", () => {
+  passThrough();
+  process.exit(0);
+});
+
+main();

package/src/hooks/comment-checker.ts

@@ -16,6 +16,8 @@ import {
   getCheckableFilePath,
   getContentToCheck,
 } from "../core/comment-checker.js";
+import { findAideBinary } from "../core/aide-client.js";
+import { emitInjectionEvent } from "../core/read-tracking.js";
 
 const SOURCE = "comment-checker";
 
@@ -53,6 +55,8 @@ async function main(): Promise<void> {
     const data: HookInput = JSON.parse(input);
     const toolName = data.tool_name || "";
     const toolInput = data.tool_input || {};
+    const cwd = data.cwd || process.cwd();
+    const sessionId = data.session_id || "";
 
     // Only check Write/Edit/MultiEdit tool calls
     const filePath = getCheckableFilePath(toolName, toolInput);
@@ -76,6 +80,28 @@ async function main(): Promise<void> {
         SOURCE,
         `Detected ${result.suspiciousCount} suspicious comments in ${filePath}`,
       );
+      try {
+        const binary = findAideBinary({
+          cwd,
+          pluginRoot:
+            process.env.AIDE_PLUGIN_ROOT || process.env.CLAUDE_PLUGIN_ROOT,
+        });
+        if (binary && result.warning) {
+          emitInjectionEvent(binary, cwd, {
+            source: SOURCE,
+            subtype: "guard",
+            content: result.warning,
+            sessionId,
+            attrs: {
+              tool: toolName,
+              file: filePath,
+              suspicious_count: String(result.suspiciousCount),
+            },
+          });
+        }
+      } catch {
+        // Non-fatal
+      }
       const output: HookOutput = {
         continue: true,
         hookSpecificOutput: {