opencode-context-dropper-plugin 0.1.6 → 0.2.0

package/dist/index.js

@@ -12336,7 +12336,7 @@ tool.schema = exports_external;
 // ../package.json
 var package_default = {
   name: "context-dropper",
-  version: "0.1.6",
+  version: "0.2.0",
   description: "CLI for iterating through a fixed list of files, tracking position, and tagging progress within an AI agent's session.",
   author: {
     name: "Fardjad Davari",
@@ -12373,6 +12373,12 @@ var package_default = {
 var getPackageVersion = () => package_default.version;
 
 // src/logger.ts
+var toastVariant = {
+  debug: "info",
+  info: "success",
+  warn: "warning",
+  error: "error"
+};
 function createLogger(service, client) {
   return (msg, extra, level = "info") => {
     client.app.log({
@@ -12385,40 +12391,286 @@ function createLogger(service, client) {
     }).catch((e) => {
       console.error(`[${service}] Failed to send log: ${e}`);
     });
+    if (process.env.CONTEXT_DROPPER_TOAST_LOGS) {
+      client.tui.showToast({
+        body: {
+          title: `[${service}] ${level.toUpperCase()}`,
+          message: msg,
+          variant: toastVariant[level],
+          duration: 4000
+        }
+      }).catch((e) => {
+        console.error(`[${service}] Failed to show toast: ${e}`);
+      });
+    }
   };
 }
 
+// src/message-handler.ts
+function compilePattern(pattern) {
+  const paramNames = [];
+  const paramTypes = [];
+  const regexSource = pattern.replace(/<(string|number):([^>]+)>/g, (_, type, name) => {
+    paramNames.push(name);
+    paramTypes.push(type);
+    return type === "number" ? "(-?\\d+(?:\\.\\d+)?)" : "(.+?)";
+  });
+  return {
+    regex: new RegExp(`^${regexSource}$`, "is"),
+    paramNames,
+    paramTypes
+  };
+}
+
+class MessageHandler {
+  routes = [];
+  use(pattern, handler) {
+    const { regex, paramNames, paramTypes } = compilePattern(pattern);
+    this.routes.push({ regex, paramNames, paramTypes, handler });
+    return this;
+  }
+  get handle() {
+    return async (input, output) => {
+      const sessionId = input.sessionID;
+      const messageId = output.message?.id;
+      for (const part of output.parts) {
+        if (part.type !== "text")
+          continue;
+        const text = part.text.trim();
+        for (const route of this.routes) {
+          const match = text.match(route.regex);
+          if (!match)
+            continue;
+          const params = {};
+          route.paramNames.forEach((name, i) => {
+            const raw = match[i + 1];
+            params[name] = route.paramTypes[i] === "number" ? Number(raw) : raw;
+          });
+          const result = await route.handler(params, {
+            sessionId,
+            messageId,
+            input,
+            output
+          });
+          if (typeof result === "string") {
+            part.text = result;
+          }
+          break;
+        }
+      }
+    };
+  }
+}
+
+// src/dropper.ts
+import path from "node:path";
+
+class Dropper {
+  filesetName;
+  dropperName;
+  log;
+  dropperService;
+  dataDir;
+  constructor(cwd, filesetName, dropperName, log, dropperService) {
+    this.filesetName = filesetName;
+    this.dropperName = dropperName;
+    this.log = log;
+    this.dropperService = dropperService;
+    this.dataDir = path.resolve(cwd, ".context-dropper");
+  }
+  async create() {
+    this.log(`Creating dropper`, {
+      dropperName: this.dropperName,
+      filesetName: this.filesetName
+    });
+    try {
+      await this.dropperService.remove({
+        dataDir: this.dataDir,
+        dropperName: this.dropperName
+      });
+    } catch (e) {
+      if (e.message && e.message.includes("not found")) {} else {
+        throw e;
+      }
+    }
+    await this.dropperService.create({
+      dataDir: this.dataDir,
+      filesetName: this.filesetName,
+      dropperName: this.dropperName
+    });
+  }
+  async tagProcessed() {
+    this.log(`Tagging current file as 'processed'`, {
+      dropperName: this.dropperName
+    });
+    await this.dropperService.tag({
+      dataDir: this.dataDir,
+      dropperName: this.dropperName,
+      tags: ["processed"]
+    });
+  }
+  async isDone() {
+    this.log(`Checking if done`, { dropperName: this.dropperName });
+    try {
+      await this.dropperService.isDone({
+        dataDir: this.dataDir,
+        dropperName: this.dropperName
+      });
+      return true;
+    } catch (e) {
+      return false;
+    }
+  }
+  async nextFile() {
+    this.log(`Advancing to next file`, { dropperName: this.dropperName });
+    await this.dropperService.next({
+      dataDir: this.dataDir,
+      dropperName: this.dropperName
+    });
+  }
+  async getCurrentFile() {
+    const dump = await this.dropperService.dump({
+      dataDir: this.dataDir,
+      dropperName: this.dropperName
+    });
+    const index = dump.pointer.currentIndex;
+    if (index === null) {
+      throw new Error("No current file found");
+    }
+    const filePath = dump.entries[index]?.path;
+    if (!filePath) {
+      throw new Error("No current file found");
+    }
+    let fileContent = "";
+    try {
+      fileContent = await this.dropperService.show({
+        dataDir: this.dataDir,
+        dropperName: this.dropperName
+      });
+    } catch (e) {
+      fileContent = `Error reading file: ${e.message}`;
+    }
+    return { path: filePath, content: fileContent };
+  }
+}
+
 // src/session.ts
+class Session {
+  options;
+  log;
+  dropperService;
+  dropper;
+  #pruneMessageId;
+  constructor(options, log, dropperService) {
+    this.options = options;
+    this.log = log;
+    this.dropperService = dropperService;
+    this.dropper = new Dropper(options.cwd, options.filesetName, `opencode-${options.filesetName}-${options.sessionId}`, log, dropperService);
+  }
+  set pruneMessageId(messageId) {
+    this.log(`Prune anchor set`, {
+      sessionId: this.options.sessionId,
+      messageId
+    });
+    this.#pruneMessageId = messageId;
+  }
+  get pruneMessageId() {
+    return this.#pruneMessageId;
+  }
+  pruneMessages(messages) {
+    if (!messages || messages.length === 0)
+      return 0;
+    if (!this.pruneMessageId)
+      return 0;
+    const totalBefore = messages.length;
+    const index = messages.findIndex((m) => m.info && m.info.id === this.pruneMessageId);
+    if (index !== -1) {
+      const assistantMessage = messages[index];
+      if (assistantMessage) {
+        if (assistantMessage.role === "assistant" || assistantMessage.info?.role === "assistant") {
+          if (typeof assistantMessage.content === "string") {
+            assistantMessage.content = "";
+          }
+          if (Array.isArray(assistantMessage.parts)) {
+            assistantMessage.parts = assistantMessage.parts.filter((p) => p.type !== "text" && p.type !== "reasoning");
+          }
+          if (Array.isArray(assistantMessage.content)) {
+            assistantMessage.content = assistantMessage.content.filter((p) => p.type !== "text" && p.type !== "reasoning");
+          }
+        }
+      }
+      messages.splice(0, index);
+      this.log(`Deep context prune completed`, {
+        sessionId: this.options.sessionId,
+        removed: index,
+        totalBefore,
+        remaining: messages.length
+      });
+      return index;
+    }
+    return 0;
+  }
+  async initDropper() {
+    await this.dropper.create();
+  }
+  async getCurrentFile() {
+    return this.dropper.getCurrentFile();
+  }
+  async getPrompt() {
+    const file2 = await this.getCurrentFile();
+    return `<context_dropper_session id="${this.dropperName}">
+` + `You are currently processing a file injected by Context-Dropper. ` + `**DO NOT use any tools to read this file again.** The complete file content is already provided below.
+
+` + `<instructions>
+` + `${this.options.instructions}
+` + `</instructions>
+
+` + `<file path="${file2.path}">
+` + `${file2.content}
+` + `</file>
+
+` + `**IMPORTANT:** When you are completely finished fulfilling the instructions for this specific file, ` + `you MUST call the \`context-dropper_next\` tool to get the next file. Do not stop until all files are processed.
+` + `</context_dropper_session>`;
+  }
+  async tagProcessed() {
+    return this.dropper.tagProcessed();
+  }
+  async isDone() {
+    return this.dropper.isDone();
+  }
+  async nextFile() {
+    return this.dropper.nextFile();
+  }
+  get dropperName() {
+    return this.dropper.dropperName;
+  }
+}
+
 class SessionManager {
-  sessionStates = new Map;
-  sessionPruneMap = new Map;
+  dropperService;
+  sessions = new Map;
   log;
-  constructor(log) {
+  cwd;
+  constructor(cwd, log, dropperService) {
+    this.dropperService = dropperService;
+    this.cwd = cwd;
     this.log = log;
   }
-  setSession(sessionId, state) {
-    this.sessionStates.set(sessionId, state);
+  async createSession(sessionId, filesetName, instructions) {
+    const session = new Session({ sessionId, filesetName, instructions, cwd: this.cwd }, this.log, this.dropperService);
+    this.sessions.set(sessionId, session);
+    await session.initDropper();
+    return session;
   }
   getSession(sessionId) {
-    return this.sessionStates.get(sessionId);
+    return this.sessions.get(sessionId);
   }
   deleteSession(sessionId) {
     this.log(`Deleting session ${sessionId}`);
-    this.sessionStates.delete(sessionId);
-    this.sessionPruneMap.delete(sessionId);
-  }
-  setPruneMessageId(sessionId, messageId) {
-    this.log(`Prune anchor set`, { sessionId, messageId });
-    this.sessionPruneMap.set(sessionId, messageId);
-  }
-  getPruneMessageId(sessionId) {
-    return this.sessionPruneMap.get(sessionId);
+    this.sessions.delete(sessionId);
   }
 }
 
-// src/toolkit.ts
-import path3 from "node:path";
-
 // ../src/dropper/service.ts
 import {
   mkdir,
@@ -12429,7 +12681,7 @@ import {
   writeFile,
   access
 } from "node:fs/promises";
-import path from "node:path";
+import path2 from "node:path";
 
 // ../src/file-utils/errors.ts
 class AppError extends Error {
@@ -12499,16 +12751,16 @@ var defaultDropperServiceDeps = {
   }
 };
 function getFilesetsDirectory(dataDir) {
-  return path.join(dataDir, "filesets");
+  return path2.join(dataDir, "filesets");
 }
 function getDroppersDirectory(dataDir) {
-  return path.join(dataDir, "droppers");
+  return path2.join(dataDir, "droppers");
 }
 function getFilesetFilePath(dataDir, filesetName) {
-  return path.join(getFilesetsDirectory(dataDir), `${filesetName}.txt`);
+  return path2.join(getFilesetsDirectory(dataDir), `${filesetName}.txt`);
 }
 function getDropperFilePath(dataDir, dropperName) {
-  return path.join(getDroppersDirectory(dataDir), `${dropperName}.json`);
+  return path2.join(getDroppersDirectory(dataDir), `${dropperName}.json`);
 }
 function parseFilesetContent(content) {
   return content.split(/\r?\n/g).map((line) => line.trim()).filter((line) => line.length > 0);
@@ -12769,391 +13021,109 @@ ${untaggedPaths.join(`
   }
 }
 
-// ../src/fileset/service.ts
-import {
-  mkdir as mkdir2,
-  readdir as readdir2,
-  rm as rm2,
-  stat as stat2,
-  readFile as readFile2,
-  writeFile as writeFile2,
-  access as access2
-} from "node:fs/promises";
-import path2 from "node:path";
-function isNotFoundError2(error45) {
-  return typeof error45 === "object" && error45 !== null && "code" in error45 && error45.code === "ENOENT";
-}
-var defaultFilesetServiceDeps = {
-  ensureDirFn: async (directoryPath) => {
-    await mkdir2(directoryPath, { recursive: true });
-  },
-  fileExistsFn: async (filePath) => {
-    try {
-      await access2(filePath);
-      return true;
-    } catch {
-      return false;
-    }
-  },
-  writeTextFileFn: async (filePath, content) => {
-    await writeFile2(filePath, content, "utf-8");
-  },
-  readTextFileFn: async (filePath) => {
-    return await readFile2(filePath, "utf-8");
-  },
-  listFilesFn: async (directoryPath) => {
-    try {
-      const names = await readdir2(directoryPath);
-      return names.map((name) => path2.join(directoryPath, name));
-    } catch (error45) {
-      if (isNotFoundError2(error45)) {
-        return [];
-      }
-      throw error45;
-    }
-  },
-  deleteFileFn: async (filePath) => {
-    await rm2(filePath);
-  },
-  statFileFn: async (filePath) => {
-    const fileStat = await stat2(filePath);
-    return {
-      createdAt: fileStat.ctime.toISOString(),
-      updatedAt: fileStat.mtime.toISOString()
-    };
-  }
-};
-function getFilesetsDirectory2(dataDir) {
-  return path2.join(dataDir, "filesets");
-}
-function getDroppersDirectory2(dataDir) {
-  return path2.join(dataDir, "droppers");
-}
-function getFilesetFilePath2(dataDir, filesetName) {
-  return path2.join(getFilesetsDirectory2(dataDir), `${filesetName}.txt`);
-}
-function parseFilesetContent2(content) {
-  return content.split(/\r?\n/g).map((line) => line.trim()).filter((line) => line.length > 0);
-}
-function parseDropperReference(rawJson, dropperPath) {
-  let parsed;
-  try {
-    parsed = JSON.parse(rawJson);
-  } catch {
-    throw new AppError(`Invalid dropper metadata: ${dropperPath}`);
-  }
-  if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed) || typeof parsed.fileset !== "string") {
-    throw new AppError(`Invalid dropper metadata: ${dropperPath}`);
-  }
-  return {
-    fileset: parsed.fileset
-  };
-}
-
-class DefaultFilesetService {
-  deps;
-  constructor(deps = defaultFilesetServiceDeps) {
-    this.deps = deps;
-  }
-  async importFromList(input) {
-    const filesetsDirectory = getFilesetsDirectory2(input.dataDir);
-    const filesetFilePath = getFilesetFilePath2(input.dataDir, input.name);
-    await this.deps.ensureDirFn(filesetsDirectory);
-    if (await this.deps.fileExistsFn(filesetFilePath)) {
-      throw new AppError(`Fileset already exists: ${input.name}`);
-    }
-    const content = input.normalizedFilePaths.length === 0 ? "" : `${input.normalizedFilePaths.join(`
-`)}
-`;
-    await this.deps.writeTextFileFn(filesetFilePath, content);
-  }
-  async list(input) {
-    const filesetPaths = (await this.deps.listFilesFn(getFilesetsDirectory2(input.dataDir))).filter((filePath) => filePath.endsWith(".txt")).sort((a, b) => path2.basename(a).localeCompare(path2.basename(b)));
-    const records = [];
-    for (const filesetPath of filesetPaths) {
-      const name = path2.basename(filesetPath, ".txt");
-      records.push(await this.show({
-        dataDir: input.dataDir,
-        name
-      }));
-    }
-    return records;
-  }
-  async show(input) {
-    const filesetFilePath = getFilesetFilePath2(input.dataDir, input.name);
-    if (!await this.deps.fileExistsFn(filesetFilePath)) {
-      throw new AppError(`Fileset not found: ${input.name}`);
-    }
-    const [content, fileStat] = await Promise.all([
-      this.deps.readTextFileFn(filesetFilePath),
-      this.deps.statFileFn(filesetFilePath)
-    ]);
-    return {
-      name: input.name,
-      files: parseFilesetContent2(content),
-      createdAt: fileStat.createdAt,
-      updatedAt: fileStat.updatedAt
-    };
-  }
-  async remove(input) {
-    const filesetFilePath = getFilesetFilePath2(input.dataDir, input.name);
-    if (!await this.deps.fileExistsFn(filesetFilePath)) {
-      throw new AppError(`Fileset not found: ${input.name}`);
-    }
-    const dependentDroppers = [];
-    const dropperPaths = (await this.deps.listFilesFn(getDroppersDirectory2(input.dataDir))).filter((dropperPath) => dropperPath.endsWith(".json"));
-    for (const dropperPath of dropperPaths) {
-      const dropperContent = await this.deps.readTextFileFn(dropperPath);
-      const reference = parseDropperReference(dropperContent, dropperPath);
-      if (reference.fileset === input.name) {
-        dependentDroppers.push(path2.basename(dropperPath, ".json"));
-      }
-    }
-    if (dependentDroppers.length > 0) {
-      throw new AppError(`Cannot remove fileset ${input.name}: referenced by droppers: ${dependentDroppers.join(", ")}`);
-    }
-    await this.deps.deleteFileFn(filesetFilePath);
-  }
-}
-
-// src/toolkit.ts
-class Toolkit {
-  dropperService;
-  filesetService;
-  dataDir;
+// src/index.ts
+class Program {
+  sessionManager;
   log;
-  constructor(cwd, log, dropperService, filesetService) {
+  messageHandler;
+  constructor(sessionManager, log) {
+    this.sessionManager = sessionManager;
     this.log = log;
-    this.dropperService = dropperService ?? new DefaultDropperService;
-    this.filesetService = filesetService ?? new DefaultFilesetService;
-    this.dataDir = path3.resolve(cwd, ".context-dropper");
-  }
-  async createDropper(filesetName, dropperName) {
-    this.log(`Creating dropper`, { dropperName, filesetName });
-    await this.dropperService.create({
-      dataDir: this.dataDir,
-      filesetName,
-      dropperName
-    });
-  }
-  async removeDropper(dropperName) {
-    this.log(`Removing dropper`, { dropperName });
-    try {
-      await this.dropperService.remove({
-        dataDir: this.dataDir,
-        dropperName
-      });
-    } catch (e) {
-      if (e.message && e.message.includes("not found")) {
-        return;
+    this.messageHandler = new MessageHandler;
+    this.messageHandler.use(":context-dropper <string:filesetName> <string:instructions>", async ({ filesetName, instructions }, { sessionId, messageId, input }) => {
+      this.log(`Processing :context-dropper command`, { sessionId });
+      const session = await this.sessionManager.createSession(sessionId, String(filesetName), String(instructions));
+      try {
+        const prompt = await session.getPrompt();
+        if (messageId)
+          session.pruneMessageId = messageId;
+        return prompt;
+      } catch (error45) {
+        this.log(`Error handling :context-dropper command`, { error: error45.message }, "error");
+        return `Error handling :context-dropper: ${error45.message}`;
       }
-      throw e;
-    }
-  }
-  async tagProcessed(dropperName) {
-    this.log(`Tagging current file as 'processed'`, { dropperName });
-    await this.dropperService.tag({
-      dataDir: this.dataDir,
-      dropperName,
-      tags: ["processed"]
-    });
-  }
-  async isDone(dropperName) {
-    this.log(`Checking if done`, { dropperName });
-    try {
-      await this.dropperService.isDone({
-        dataDir: this.dataDir,
-        dropperName
-      });
-      return true;
-    } catch (e) {
-      return false;
-    }
-  }
-  async nextFile(dropperName) {
-    this.log(`Advancing to next file`, { dropperName });
-    await this.dropperService.next({
-      dataDir: this.dataDir,
-      dropperName
     });
   }
-  async getFilePrompt(dropperName, instructions, isNext = false) {
-    const dump = await this.dropperService.dump({
-      dataDir: this.dataDir,
-      dropperName
-    });
-    const index = dump.pointer.currentIndex;
-    const filePath = index !== null && index >= 0 && index < dump.entries.length ? dump.entries[index]?.path ?? "Unknown File" : "Unknown File";
-    let fileContent = "";
-    try {
-      fileContent = await this.dropperService.show({
-        dataDir: this.dataDir,
-        dropperName
-      });
-    } catch (e) {
-      fileContent = `Error reading file: ${e.message}`;
-    }
-    const header = isNext ? `[Context-Dropper: Advanced to next file]` : `Context-dropper task initialized for session '${dropperName}'.`;
-    return `${header}
-
-` + `Instructions for this file:
-${instructions}
-
-` + `File: ${filePath}
-
-` + `File Content:
-${fileContent}
-
-` + `When you are done with this file, DO NOT just say "DONE". You MUST call the 'context-dropper.next' tool to automatically fetch the next file.`;
+  getActiveSession(messages) {
+    if (!messages || messages.length === 0)
+      return;
+    const firstMessage = messages[0];
+    if (!firstMessage || !firstMessage.info)
+      return;
+    const sessionId = firstMessage.info.sessionID;
+    if (!sessionId)
+      return;
+    return this.sessionManager.getSession(sessionId);
   }
-}
-
-// src/index.ts
-var ContextDropperPlugin = async (ctx) => {
-  const version2 = getPackageVersion();
-  const log = createLogger("context-dropper", ctx.client);
-  const toolkit = new Toolkit(ctx.worktree, log);
-  const sessionManager = new SessionManager(log);
-  log(`Plugin initializing! Version: ${version2}`);
-  setTimeout(() => {
-    ctx.client.tui.showToast({
-      body: {
-        title: `Context Dropper v${version2}`,
-        message: "Plugin is active! Type '/drop <filesetName> <instructions>' to start.",
-        variant: "success",
-        duration: 5000
-      }
-    }).catch((e) => log("Failed to show toast", { error: String(e) }, "warn"));
-    log("Initialization complete", { worktree: ctx.worktree, version: version2 });
-  }, 1000);
-  return {
-    tool: {
-      "context-dropper": tool({
+  get tools() {
+    return {
+      "context-dropper_init": tool({
         description: "Initializes the context-dropper task.",
         args: {
           filesetName: tool.schema.string().describe("The name of the fileset to process"),
           instructions: tool.schema.string().describe("Instructions on what to do with the files")
         },
         execute: async (args, context) => {
-          const dropperName = `session-${context.sessionID}`;
-          sessionManager.setSession(context.sessionID, {
-            dropperName,
-            instructions: args.instructions
-          });
+          const { filesetName, instructions } = args;
+          const sessionId = context.sessionID;
+          const session = await this.sessionManager.createSession(sessionId, filesetName, instructions);
           try {
-            await toolkit.removeDropper(dropperName);
-            await toolkit.createDropper(args.filesetName, dropperName);
-            return await toolkit.getFilePrompt(dropperName, args.instructions, false);
+            return await session.getPrompt();
           } catch (error45) {
-            log(`Error in tool execution`, { error: error45.message }, "error");
-            return `Error initializing context-dropper: ${error45.message}`;
+            this.log(`Error in context-dropper_init`, { error: error45.message }, "error");
+            return `Error in context-dropper_init: ${error45.message}`;
           }
         }
       }),
-      "context-dropper.next": tool({
+      "context-dropper_next": tool({
         description: "Call this tool when you have finished processing the current file to save state, prune context, and fetch the next file.",
         args: {},
         execute: async (args, context) => {
           const sessionId = context.sessionID;
-          const state = sessionManager.getSession(sessionId);
-          if (!state) {
+          const session = this.sessionManager.getSession(sessionId);
+          if (!session) {
             return "No active context-dropper session found. Please initialize one first.";
           }
           try {
-            await toolkit.tagProcessed(state.dropperName);
-            const isDone = await toolkit.isDone(state.dropperName);
+            await session.tagProcessed();
+            const isDone = await session.isDone();
             if (isDone) {
-              log(`Session completed`, { dropperName: state.dropperName });
-              sessionManager.deleteSession(sessionId);
+              this.log(`Session completed`, {
+                dropperName: session.dropperName
+              });
+              this.sessionManager.deleteSession(sessionId);
               return `[Context-Dropper: All files have been processed. Task complete.]`;
             }
-            await toolkit.nextFile(state.dropperName);
-            const prompt = await toolkit.getFilePrompt(state.dropperName, state.instructions, true);
-            sessionManager.setPruneMessageId(sessionId, context.messageID);
+            await session.nextFile();
+            const prompt = await session.getPrompt();
+            session.pruneMessageId = context.messageID;
             return prompt;
           } catch (error45) {
-            log(`Error during 'next' processing`, { error: error45.message }, "error");
-            return `[Context-Dropper Error: ${error45.message}]`;
+            this.log(`Error in context-dropper_next`, { error: error45.message }, "error");
+            return `[context-dropper_next error: ${error45.message}]`;
           }
         }
       })
-    },
-    "chat.message": async (input, output) => {
-      const sessionId = input.sessionID;
-      for (const part of output.parts) {
-        if (part.type === "text") {
-          const text = part.text.trim().toLowerCase();
-          log(`Processing message chunk`, {
-            sessionId,
-            startsWithDrop: text.startsWith("/drop")
-          });
-          if (text.startsWith("/drop ")) {
-            const originalText = part.text.trim();
-            const match = originalText.match(/^\/drop\s+([^\s]+)\s+(.+)$/is);
-            if (match) {
-              const filesetName = match[1] || "";
-              const instructions = match[2] || "";
-              const dropperName = `session-${sessionId}`;
-              sessionManager.setSession(sessionId, {
-                dropperName,
-                instructions
-              });
-              try {
-                await toolkit.removeDropper(dropperName);
-                await toolkit.createDropper(filesetName, dropperName);
-                const prompt = await toolkit.getFilePrompt(dropperName, instructions, false);
-                part.text = prompt;
-                if (output.message?.id) {
-                  sessionManager.setPruneMessageId(sessionId, output.message.id);
-                }
-              } catch (error45) {
-                log(`Error starting context-dropper via /drop`, {
-                  error: error45.message
-                }, "error");
-                part.text = `Error starting context-dropper: ${error45.message}`;
-              }
-            } else {
-              part.text = "Invalid command format. Please use: `/drop <filesetName> <instructions>`";
-            }
-            continue;
-          }
-          if (text.includes("stop context-dropper") || text.includes("stop dropping")) {
-            sessionManager.deleteSession(sessionId);
-            part.text += `
-
-[Context-Dropper: Process stopped manually by user. State cleared.]`;
-            continue;
-          }
-        }
-      }
-    },
-    "experimental.chat.messages.transform": async (input, output) => {
-      if (!output.messages || output.messages.length === 0)
-        return;
-      const firstMessage = output.messages[0];
-      if (!firstMessage || !firstMessage.info)
-        return;
-      const sessionId = firstMessage.info.sessionID;
-      if (!sessionId)
-        return;
-      const pruneStartId = sessionManager.getPruneMessageId(sessionId);
-      if (pruneStartId) {
-        const totalBefore = output.messages.length;
-        const index = output.messages.findIndex((m) => m.info && m.info.id === pruneStartId);
-        if (index !== -1) {
-          output.messages.splice(0, index);
-          log(`Context pruned`, {
-            sessionId,
-            removed: index,
-            totalBefore,
-            remaining: output.messages.length
-          });
-        }
+    };
+  }
+  get plugin() {
+    return {
+      tool: this.tools,
+      "chat.message": this.messageHandler.handle,
+      "experimental.chat.messages.transform": async (_input, output) => {
+        const activeSession = this.getActiveSession(output.messages);
+        activeSession?.pruneMessages(output.messages);
       }
-    }
-  };
+    };
+  }
+}
+var src_default = async (ctx) => {
+  const log = createLogger("context-dropper", ctx.client);
+  log(`Plugin initializing! Version: ${getPackageVersion()}`);
+  const dropperService = new DefaultDropperService;
+  const sessionManager = new SessionManager(ctx.worktree, log, dropperService);
+  return new Program(sessionManager, log).plugin;
 };
-var src_default = ContextDropperPlugin;
 export {
   src_default as default
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-context-dropper-plugin",
-  "version": "0.1.6",
+  "version": "0.2.0",
   "description": "A Context Dropper plugin for OpenCode that automates file iteration context management.",
   "author": {
     "name": "Fardjad Davari",