@jmylchreest/aide-plugin 0.0.24 → 0.0.26

package/src/core/session-summary-logic.ts

@@ -169,9 +169,7 @@ export function buildSessionSummaryFromState(cwd: string): string | null {
   const summaryParts: string[] = [];
 
   if (commits.length > 0) {
-    summaryParts.push(
-      `## Commits\n${commits.map((c) => `- ${c}`).join("\n")}`,
-    );
+    summaryParts.push(`## Commits\n${commits.map((c) => `- ${c}`).join("\n")}`);
   }
 
   // Check for modified files via git
@@ -216,14 +214,12 @@ export function storeSessionSummary(
   summary: string,
 ): boolean {
   try {
-    const dbPath = join(cwd, ".aide", "memory", "store.db");
-    const env = { ...process.env, AIDE_MEMORY_DB: dbPath };
     const tags = `session-summary,session:${sessionId.slice(0, 8)}`;
 
     execFileSync(
       binary,
       ["memory", "add", "--category=session", `--tags=${tags}`, summary],
-      { env, stdio: "pipe", timeout: 5000 },
+      { cwd, stdio: "pipe", timeout: 5000 },
     );
 
     return true;

package/src/opencode/hooks.ts

@@ -25,6 +25,7 @@
  *   Stop (blocking)            → session.idle re-prompts via session.prompt() for persistence
  */
 
+import { execFileSync } from "child_process";
 import { findAideBinary } from "../core/aide-client.js";
 import {
   ensureDirectories,
@@ -56,10 +57,24 @@ import { saveStateSnapshot } from "../core/pre-compact-logic.js";
 import { cleanupSession } from "../core/cleanup.js";
 import {
   buildSessionSummaryFromState,
+  getSessionCommits,
   storeSessionSummary,
 } from "../core/session-summary-logic.js";
+import {
+  storePartialMemory,
+  gatherPartials,
+  buildSummaryFromPartials,
+  cleanupPartials,
+} from "../core/partial-memory.js";
 import type { MemoryInjection, SessionState } from "../core/types.js";
-import type { Hooks, OpenCodeClient, OpenCodeEvent } from "./types.js";
+import type {
+  Hooks,
+  OpenCodeClient,
+  OpenCodeConfig,
+  OpenCodeEvent,
+  OpenCodeSession,
+  OpenCodePart,
+} from "./types.js";
 import { debug } from "../lib/logger.js";
 
 const SOURCE = "opencode-hooks";
@@ -81,6 +96,8 @@ interface AideState {
   binary: string | null;
   cwd: string;
   worktree: string;
+  /** Root of the aide plugin package (for finding bundled skills) */
+  pluginRoot: string | null;
   sessionState: SessionState | null;
   memories: MemoryInjection | null;
   welcomeContext: string | null;
@@ -90,6 +107,8 @@ interface AideState {
   processedMessageParts: Set<string>;
   /** Matched skills pending injection via system transform */
   pendingSkillsContext: string | null;
+  /** Last user prompt text, used for skill matching in system transform */
+  lastUserPrompt: string | null;
   /** Per-session metadata for agent-like tracking */
   sessionInfoMap: Map<string, SessionInfo>;
   client: OpenCodeClient;
@@ -102,18 +121,21 @@ export async function createHooks(
   cwd: string,
   worktree: string,
   client: OpenCodeClient,
+  pluginRoot?: string,
 ): Promise<Hooks> {
   const state: AideState = {
     initialized: false,
     binary: null,
     cwd,
     worktree,
+    pluginRoot: pluginRoot || null,
     sessionState: null,
     memories: null,
     welcomeContext: null,
     initializedSessions: new Set(),
     processedMessageParts: new Set(),
     pendingSkillsContext: null,
+    lastUserPrompt: null,
     sessionInfoMap: new Map(),
     client,
   };
@@ -123,6 +145,8 @@ export async function createHooks(
 
   return {
     event: createEventHandler(state),
+    config: createConfigHandler(state),
+    "command.execute.before": createCommandHandler(state),
     "tool.execute.before": createToolBeforeHandler(state),
     "tool.execute.after": createToolAfterHandler(state),
     "experimental.session.compacting": createCompactionHandler(state),
@@ -132,6 +156,94 @@ export async function createHooks(
   };
 }
 
+// =============================================================================
+// Config handler (register aide commands as OpenCode slash commands)
+// =============================================================================
+
+function createConfigHandler(
+  state: AideState,
+): (input: OpenCodeConfig) => Promise<void> {
+  return async (input) => {
+    try {
+      // Discover all skills and register them as OpenCode commands
+      const skills = discoverSkills(state.cwd, state.pluginRoot ?? undefined);
+
+      if (!input.command) {
+        input.command = {};
+      }
+
+      for (const skill of skills) {
+        const commandName = `aide:${skill.name}`;
+        // Only register if not already defined (user config takes priority)
+        if (!input.command[commandName]) {
+          input.command[commandName] = {
+            template: `Activate the aide "${skill.name}" skill. {{arguments}}`,
+            description: skill.description || `aide ${skill.name} skill`,
+          };
+        }
+      }
+
+      debug(
+        SOURCE,
+        `Registered ${skills.length} aide commands via config hook`,
+      );
+    } catch (err) {
+      debug(SOURCE, `Config hook failed (non-fatal): ${err}`);
+    }
+  };
+}
+
+// =============================================================================
+// Command handler (intercept aide slash command execution)
+// =============================================================================
+
+function createCommandHandler(state: AideState): (
+  input: { command: string; sessionID: string; arguments: string },
+  output: {
+    parts: Array<{ type: string; text: string; [key: string]: unknown }>;
+  },
+) => Promise<void> {
+  return async (input, output) => {
+    // Only handle aide: prefixed commands
+    if (!input.command.startsWith("aide:")) return;
+
+    const skillName = input.command.slice("aide:".length);
+    const args = input.arguments || "";
+
+    try {
+      const skills = discoverSkills(state.cwd, state.pluginRoot ?? undefined);
+      const skill = skills.find((s) => s.name === skillName);
+
+      if (skill) {
+        // Format the skill content for injection
+        const context = formatSkillsContext([skill]);
+
+        // Store for system transform injection
+        state.pendingSkillsContext = context;
+
+        // Also store the arguments as the user prompt for the transform
+        if (args) {
+          state.lastUserPrompt = args;
+        }
+
+        debug(SOURCE, `Command handler activated skill: ${skillName}`);
+
+        await state.client.app.log({
+          body: {
+            service: "aide",
+            level: "info",
+            message: `Activated skill: ${skillName}${args ? ` with args: ${args.slice(0, 50)}` : ""}`,
+          },
+        });
+      } else {
+        debug(SOURCE, `Command handler: unknown skill "${skillName}"`);
+      }
+    } catch (err) {
+      debug(SOURCE, `Command handler failed (non-fatal): ${err}`);
+    }
+  };
+}
+
 // =============================================================================
 // Initialization
 // =============================================================================
@@ -195,11 +307,33 @@ function createEventHandler(
   };
 }
 
+/**
+ * Extract session ID from an event. OpenCode uses different shapes:
+ * - session.created/deleted/updated: { properties: { info: { id: string } } }
+ * - session.idle/compacted:          { properties: { sessionID: string } }
+ * - message.part.updated:            { properties: { part: { sessionID: string } } }
+ */
+function extractSessionId(event: OpenCodeEvent): string {
+  // session.created / session.deleted / session.updated — nested under info
+  const info = event.properties.info as OpenCodeSession | undefined;
+  if (info?.id) return info.id;
+
+  // session.idle, session.compacted, tool hooks — direct sessionID
+  const sessionID = event.properties.sessionID as string | undefined;
+  if (sessionID) return sessionID;
+
+  // message.part.updated — sessionID on the part object
+  const part = event.properties.part as OpenCodePart | undefined;
+  if (part && "sessionID" in part && part.sessionID) return part.sessionID;
+
+  return "unknown";
+}
+
 async function handleSessionCreated(
   state: AideState,
   event: OpenCodeEvent,
 ): Promise<void> {
-  const sessionId = (event.properties.sessionID as string) || "unknown";
+  const sessionId = extractSessionId(event);
 
   if (state.initializedSessions.has(sessionId)) return;
   state.initializedSessions.add(sessionId);
@@ -254,7 +388,7 @@ async function handleSessionIdle(
   state: AideState,
   event: OpenCodeEvent,
 ): Promise<void> {
-  const sessionId = (event.properties.sessionID as string) || "unknown";
+  const sessionId = extractSessionId(event);
 
   // Check persistence: if ralph/autopilot mode is active, re-prompt the session
   if (state.binary) {
@@ -306,10 +440,32 @@ async function handleSessionIdle(
   }
 
   // Capture session summary (best effort, no transcript available)
+  // Uses partials if available for a richer summary.
   if (state.binary) {
-    const summary = buildSessionSummaryFromState(state.cwd);
+    const partials = gatherPartials(state.binary, state.cwd, sessionId);
+    let summary: string | null = null;
+
+    if (partials.length > 0) {
+      const commits = getSessionCommits(state.cwd);
+      summary = buildSummaryFromPartials(partials, commits, []);
+      debug(SOURCE, `Built summary from ${partials.length} partials`);
+    }
+
+    // Fall back to state-only summary if no partials
+    if (!summary) {
+      summary = buildSessionSummaryFromState(state.cwd);
+    }
+
     if (summary) {
       storeSessionSummary(state.binary, state.cwd, sessionId, summary);
+      // Clean up partials now that the final summary is stored
+      const cleaned = cleanupPartials(state.binary, state.cwd, sessionId);
+      if (cleaned > 0) {
+        debug(SOURCE, `Cleaned up ${cleaned} partials after final summary`);
+      }
+    } else if (partials.length > 0) {
+      // Clean up partials even if no summary was generated
+      cleanupPartials(state.binary, state.cwd, sessionId);
     }
   }
 }
@@ -318,7 +474,7 @@ async function handleSessionDeleted(
   state: AideState,
   event: OpenCodeEvent,
 ): Promise<void> {
-  const sessionId = (event.properties.sessionID as string) || "unknown";
+  const sessionId = extractSessionId(event);
 
   if (state.binary) {
     cleanupSession(state.binary, state.cwd, sessionId);
@@ -333,19 +489,17 @@ async function handleMessagePartUpdated(
   state: AideState,
   event: OpenCodeEvent,
 ): Promise<void> {
-  // Skill injection: only process user messages
-  const part = event.properties.part as
-    | { type?: string; text?: string; role?: string }
-    | undefined;
+  // Skill injection: only process user text parts
+  const part = event.properties.part as OpenCodePart | undefined;
   if (!part) return;
 
-  // Only match skills for user text parts
-  const role = (event.properties.role as string) || part.role;
-  if (role !== "user") return;
-  if (part.type !== "text" || !part.text) return;
+  // Only match skills for text parts (user messages)
+  if (part.type !== "text") return;
+  const textContent = (part as { text?: string }).text;
+  if (!textContent) return;
 
   // Dedup: don't re-process the same part
-  const partId = (event.properties.partID as string) || "";
+  const partId = part.id || "";
   if (partId && state.processedMessageParts.has(partId)) return;
   if (partId) state.processedMessageParts.add(partId);
 
@@ -363,8 +517,13 @@ async function handleMessagePartUpdated(
     );
   }
 
-  const prompt = part.text;
-  const skills = discoverSkills(state.cwd);
+  const prompt = textContent;
+
+  // Store latest user prompt so system transform can match skills even if
+  // this event fires after the transform (defensive against ordering).
+  state.lastUserPrompt = prompt;
+
+  const skills = discoverSkills(state.cwd, state.pluginRoot ?? undefined);
   const matched = matchSkills(prompt, skills, 3);
 
   if (matched.length > 0) {
@@ -377,8 +536,6 @@ async function handleMessagePartUpdated(
           message: `Matched ${matched.length} skills: ${matched.map((s) => s.name).join(", ")}`,
         },
       });
-      // Note: OpenCode doesn't have a direct skill injection hook like Claude Code's
-      // UserPromptSubmit. Skills are logged here; injection happens via system transform.
       // Store matched skills for injection in system transform
       state.pendingSkillsContext = context;
     } catch (err) {
@@ -470,6 +627,23 @@ function createToolAfterHandler(
 
     updateToolStats(state.binary, state.cwd, input.tool, input.sessionID);
 
+    // Write a partial memory for significant tool uses
+    try {
+      const toolArgs = (_output.metadata?.args || {}) as Record<
+        string,
+        unknown
+      >;
+      storePartialMemory(state.binary, state.cwd, {
+        toolName: input.tool,
+        sessionId: input.sessionID,
+        filePath: toolArgs.file_path as string | undefined,
+        command: toolArgs.command as string | undefined,
+        description: toolArgs.description as string | undefined,
+      });
+    } catch (err) {
+      debug(SOURCE, `Partial memory write failed (non-fatal): ${err}`);
+    }
+
     // Comment checker: detect excessive comments in Write/Edit output
     try {
       const toolArgs = (_output.metadata?.args || {}) as Record<
@@ -514,18 +688,40 @@ function createCompactionHandler(
 
       // Persist a session summary as a memory before context is compacted.
       // This ensures the work-so-far is recoverable after compaction.
+      // Uses partials (if available) for a richer summary, falling back to git-only.
       try {
-        const summary = buildSessionSummaryFromState(state.cwd);
+        const partials = gatherPartials(
+          state.binary,
+          state.cwd,
+          input.sessionID,
+        );
+        let summary: string | null = null;
+
+        if (partials.length > 0) {
+          const commits = getSessionCommits(state.cwd);
+          summary = buildSummaryFromPartials(partials, commits, []);
+          debug(
+            SOURCE,
+            `Built pre-compact summary from ${partials.length} partials`,
+          );
+        }
+
+        // Fall back to state-only summary if no partials
+        if (!summary) {
+          summary = buildSessionSummaryFromState(state.cwd);
+        }
+
         if (summary) {
-          storeSessionSummary(
+          // Tag as partial so the session-end summary supersedes it
+          const tags = `partial,session-summary,session:${input.sessionID.slice(0, 8)}`;
+          execFileSync(
             state.binary,
-            state.cwd,
-            input.sessionID,
-            summary,
+            ["memory", "add", "--category=session", `--tags=${tags}`, summary],
+            { cwd: state.cwd, stdio: "pipe", timeout: 5000 },
           );
           debug(
             SOURCE,
-            `Saved pre-compaction session summary for ${input.sessionID.slice(0, 8)}`,
+            `Saved pre-compaction partial session summary for ${input.sessionID.slice(0, 8)}`,
           );
         }
       } catch (err) {
@@ -629,10 +825,26 @@ function createSystemTransformHandler(
       }
     }
 
-    // Inject any pending matched skills
+    // Inject matched skills. If message.part.updated already matched skills,
+    // use the pre-computed context. Otherwise, match inline from the last user
+    // prompt as a fallback (guards against event ordering issues).
     if (state.pendingSkillsContext) {
       output.system.push(state.pendingSkillsContext);
       state.pendingSkillsContext = null;
+    } else if (state.lastUserPrompt) {
+      try {
+        const skills = discoverSkills(state.cwd, state.pluginRoot ?? undefined);
+        const matched = matchSkills(state.lastUserPrompt, skills, 3);
+        if (matched.length > 0) {
+          output.system.push(formatSkillsContext(matched));
+          debug(
+            SOURCE,
+            `System transform fallback matched ${matched.length} skills`,
+          );
+        }
+      } catch (err) {
+        debug(SOURCE, `Fallback skill matching failed (non-critical): ${err}`);
+      }
     }
 
     // Inject messaging protocol for multi-instance coordination

package/src/opencode/index.ts

@@ -25,12 +25,21 @@
  * ```
  */
 
+import { dirname, join } from "path";
+import { fileURLToPath } from "url";
 import { createHooks } from "./hooks.js";
 import type { Plugin, PluginInput, Hooks } from "./types.js";
 
+// Resolve the plugin package root so we can find bundled skills.
+// Works whether running from source (repo) or installed via npm.
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+// index.ts lives in src/opencode/, so the package root is two levels up.
+const pluginRoot = join(__dirname, "..", "..");
+
 export const AidePlugin: Plugin = async (ctx: PluginInput): Promise<Hooks> => {
   const cwd = ctx.worktree || ctx.directory;
-  return createHooks(cwd, ctx.worktree, ctx.client);
+  return createHooks(cwd, ctx.worktree, ctx.client, pluginRoot);
 };
 
 export default AidePlugin;

package/src/opencode/types.ts

@@ -31,7 +31,9 @@ export interface PluginInput {
 /** Minimal SDK client interface — only the parts we use */
 export interface OpenCodeClient {
   app: {
-    log(opts: { body: { service: string; level: string; message: string } }): Promise<void>;
+    log(opts: {
+      body: { service: string; level: string; message: string };
+    }): Promise<void>;
   };
   session: {
     create(opts: { body: { title?: string } }): Promise<{ id: string }>;
@@ -54,11 +56,86 @@ export interface OpenCodeClient {
 // Events
 // =============================================================================
 
+/** Session object as returned in session.created/updated/deleted events */
+export interface OpenCodeSession {
+  id: string;
+  projectID: string;
+  directory: string;
+  parentID?: string;
+  title: string;
+  version: string;
+  time: {
+    created: number;
+    updated: number;
+    compacting?: number;
+  };
+}
+
+/** Text part with session context */
+export interface OpenCodeTextPart {
+  id: string;
+  sessionID: string;
+  messageID: string;
+  type: "text";
+  text: string;
+  synthetic?: boolean;
+  ignored?: boolean;
+}
+
+/** Generic part — may be text, tool, step, etc. */
+export type OpenCodePart =
+  | OpenCodeTextPart
+  | {
+      id: string;
+      sessionID: string;
+      messageID: string;
+      type: string;
+      [key: string]: unknown;
+    };
+
 export interface OpenCodeEvent {
   type: string;
   properties: Record<string, unknown>;
 }
 
+/** Typed event shapes matching the OpenCode SDK */
+export interface EventSessionCreated {
+  type: "session.created";
+  properties: { info: OpenCodeSession };
+}
+
+export interface EventSessionDeleted {
+  type: "session.deleted";
+  properties: { info: OpenCodeSession };
+}
+
+export interface EventSessionIdle {
+  type: "session.idle";
+  properties: { sessionID: string };
+}
+
+export interface EventMessagePartUpdated {
+  type: "message.part.updated";
+  properties: { part: OpenCodePart; delta?: string };
+}
+
+// =============================================================================
+// OpenCode Config (command registration)
+// =============================================================================
+
+export interface OpenCodeConfig {
+  command?: {
+    [key: string]: {
+      template: string;
+      description?: string;
+      agent?: string;
+      model?: string;
+      subtask?: boolean;
+    };
+  };
+  [key: string]: unknown;
+}
+
 // =============================================================================
 // Hook signatures
 // =============================================================================
@@ -67,6 +144,17 @@ export interface Hooks {
   /** Generic event listener for all OpenCode events */
   event?: (input: { event: OpenCodeEvent }) => Promise<void>;
 
+  /** Modify OpenCode config (register commands, etc.) */
+  config?: (input: OpenCodeConfig) => Promise<void>;
+
+  /** Intercept command execution (slash commands) */
+  "command.execute.before"?: (
+    input: { command: string; sessionID: string; arguments: string },
+    output: {
+      parts: Array<{ type: string; text: string; [key: string]: unknown }>;
+    },
+  ) => Promise<void>;
+
   /** Modify tool arguments before execution */
   "tool.execute.before"?: (
     input: { tool: string; sessionID: string; callID: string },
@@ -76,12 +164,19 @@ export interface Hooks {
   /** React after tool completes */
   "tool.execute.after"?: (
     input: { tool: string; sessionID: string; callID: string },
-    output: { title: string; output: string; metadata: Record<string, unknown> },
+    output: {
+      title: string;
+      output: string;
+      metadata: Record<string, unknown>;
+    },
   ) => Promise<void>;
 
   /** Modify system prompt */
   "experimental.chat.system.transform"?: (
-    input: { sessionID?: string; model: { providerID: string; modelID: string } },
+    input: {
+      sessionID?: string;
+      model: { providerID: string; modelID: string };
+    },
     output: { system: string[] },
   ) => Promise<void>;