opencode-context-dropper-plugin 0.1.6 → 0.2.1

package/README.md

@@ -58,11 +58,11 @@ Once installed, start OpenCode:
 opencode
 ```
 
-You can invoke the context dropper loop inside chat simply by using the `/drop`
-slash command:
+You can invoke the context dropper loop inside chat simply by using the
+`:context-dropper` slash command:
 
 ```text
-/drop <filesetName> <instructions>
+:context-dropper <filesetName> <instructions>
 ```
 
 - `<filesetName>` is the name of a pre-existing fileset in your project.
@@ -72,7 +72,7 @@ slash command:
 **Example:**
 
 ```text
-/drop backend-routes Please add try/catch blocks and proper logging to all async functions in this file.
+:context-dropper backend-routes Please add try/catch blocks and proper logging to all async functions in this file.
 ```
 
 ### The Automation Loop
@@ -82,7 +82,7 @@ Once invoked, the plugin completely takes over the context management:
 1. It automatically fetches the first file in the fileset and provides it to the
    agent along with your instructions.
 2. The agent performs the instructions and automatically calls the
-   `context-dropper.next` tool.
+   `context-dropper_next` tool.
 3. **Context Pruning**: When the tool is called, the file is tagged as
    processed. The plugin drops the previous file's context from the chat history
    (saving tokens), and feeds the next file to the agent.

package/dist/index.js

@@ -12333,46 +12333,13 @@ function tool(input) {
   return input;
 }
 tool.schema = exports_external;
-// ../package.json
-var package_default = {
-  name: "context-dropper",
-  version: "0.1.6",
-  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",
-    email: "public@fardjad.com"
-  },
-  license: "MIT",
-  repository: {
-    type: "git",
-    url: "https://github.com/fardjad/context-dropper"
-  },
-  keywords: ["cli", "context", "llm", "ai", "opencode", "automation"],
-  bin: {
-    "context-dropper": "./dist/index.js"
-  },
-  main: "dist/index.js",
-  module: "dist/index.js",
-  type: "module",
-  files: ["dist/index.js"],
-  scripts: {
-    build: "bun build ./src/index.ts --outdir ./dist --target node",
-    prepack: "npm run build"
-  },
-  devDependencies: {
-    "@types/bun": "latest",
-    typescript: "^5"
-  },
-  dependencies: {
-    "@types/yargs": "^17.0.35",
-    yargs: "^18.0.0"
-  }
-};
-
-// ../src/version/version.ts
-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 +12352,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 +12642,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 +12712,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);
@@ -12768,392 +12981,152 @@ ${untaggedPaths.join(`
     return true;
   }
 }
-
-// ../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");
+// package.json
+var package_default = {
+  name: "opencode-context-dropper-plugin",
+  version: "0.2.1",
+  description: "A Context Dropper plugin for OpenCode that automates file iteration context management.",
+  author: {
+    name: "Fardjad Davari",
+    email: "public@fardjad.com"
   },
-  readTextFileFn: async (filePath) => {
-    return await readFile2(filePath, "utf-8");
+  license: "MIT",
+  repository: {
+    type: "git",
+    url: "https://github.com/fardjad/context-dropper.git",
+    directory: "opencode-plugin"
   },
-  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;
+  keywords: ["opencode", "plugin", "context-dropper", "llm", "ai"],
+  main: "dist/index.js",
+  module: "dist/index.js",
+  type: "module",
+  exports: {
+    ".": {
+      default: "./dist/index.js"
     }
   },
-  deleteFileFn: async (filePath) => {
-    await rm2(filePath);
+  files: ["dist/index.js"],
+  scripts: {
+    build: "bun build ./src/index.ts --outdir ./dist --target node",
+    prepack: "npm run build"
   },
-  statFileFn: async (filePath) => {
-    const fileStat = await stat2(filePath);
-    return {
-      createdAt: fileStat.ctime.toISOString(),
-      updatedAt: fileStat.mtime.toISOString()
-    };
+  devDependencies: {
+    "@types/bun": "^1.3.11",
+    "@types/node": "^25.5.0",
+    typescript: "^6.0.2"
+  },
+  dependencies: {
+    "@opencode-ai/plugin": "^1.3.13",
+    zod: "^4.3.6"
   }
 };
-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/version.ts
+var getPackageVersion = () => package_default.version;
 
-// 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.1",
   "description": "A Context Dropper plugin for OpenCode that automates file iteration context management.",
   "author": {
     "name": "Fardjad Davari",
@@ -27,12 +27,12 @@
     "prepack": "npm run build"
   },
   "devDependencies": {
-    "@types/bun": "latest",
-    "@types/node": "^25.3.5",
-    "typescript": "^5"
+    "@types/bun": "^1.3.11",
+    "@types/node": "^25.5.0",
+    "typescript": "^6.0.2"
   },
   "dependencies": {
-    "@opencode-ai/plugin": "^1.2.20",
+    "@opencode-ai/plugin": "^1.3.13",
     "zod": "^4.3.6"
   }
 }