opencode-context-dropper-plugin 0.1.5 → 0.2.0

package/README.md

@@ -1,6 +1,9 @@
 # OpenCode Context Dropper Plugin
 
-A Context Dropper plugin for OpenCode, built with Bun and TypeScript. It leverages the internal `context-dropper` APIs to efficiently process a large set of files one-by-one entirely within your OpenCode sessions. It automatically tracks context and handles token pruning to allow continuous agent iteration.
+A Context Dropper plugin for OpenCode, built with Bun and TypeScript. It
+leverages the internal `context-dropper` APIs to efficiently process a large set
+of files one-by-one entirely within your OpenCode sessions. It automatically
+tracks context and handles token pruning to allow continuous agent iteration.
 
 ## Prerequisites
 
@@ -13,9 +16,12 @@ You can install the `context-dropper` plugin using one of the following methods.
 
 ### 1. Configure OpenCode (Recommended)
 
-You do not need to manually install the package. OpenCode will automatically resolve and install it from the NPM registry when you add it to your configuration.
+You do not need to manually install the package. OpenCode will automatically
+resolve and install it from the NPM registry when you add it to your
+configuration.
 
-You can configure the plugin either globally for all projects, or locally for a single project:
+You can configure the plugin either globally for all projects, or locally for a
+single project:
 
 **Option A: Project-Level (Local)**
 
@@ -30,7 +36,8 @@ You can configure the plugin either globally for all projects, or locally for a
 
 **Option B: Global-Level**
 
-1. Create or edit your global OpenCode config file at `~/.config/opencode/opencode.json`.
+1. Create or edit your global OpenCode config file at
+   `~/.config/opencode/opencode.json`.
 2. Add the package name to the `plugin` array:
 
 ```json
@@ -39,7 +46,9 @@ You can configure the plugin either globally for all projects, or locally for a
 }
 ```
 
-(Optional) If you prefer to manage the installation yourself, you can install the plugin globally using Bun (`bun install -g opencode-context-dropper-plugin`) or NPM (`npm install -g opencode-context-dropper-plugin`).
+(Optional) If you prefer to manage the installation yourself, you can install
+the plugin globally using Bun (`bun install -g opencode-context-dropper-plugin`)
+or NPM (`npm install -g opencode-context-dropper-plugin`).
 
 ## Usage
 
@@ -49,14 +58,16 @@ 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 `/drop`
+slash command:
 
 ```text
 /drop <filesetName> <instructions>
 ```
 
 - `<filesetName>` is the name of a pre-existing fileset in your project.
-- `<instructions>` is the prompt you want the AI to perform on each file sequentially.
+- `<instructions>` is the prompt you want the AI to perform on each file
+  sequentially.
 
 **Example:**
 
@@ -68,9 +79,27 @@ You can invoke the context dropper loop inside chat simply by using the `/drop`
 
 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.
-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.
+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.
+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.
 4. This loop continues until all files are processed.
 
 To forcefully stop the loop before it finishes, type **"stop context-dropper"**.
+
+## Logging
+
+Plugin activity is written to OpenCode's native log system via the
+`context-dropper` service. To view logs, run OpenCode with debug-level output
+enabled:
+
+```bash
+opencode --log-level debug
+```
+
+Unexpected errors are logged at `error` level and are visible at any log level.
+Operational events (dropper lifecycle, context pruning) are logged at `info`
+level.

package/dist/index.js

@@ -12333,14 +12333,10 @@ function tool(input) {
   return input;
 }
 tool.schema = exports_external;
-// src/index.ts
-import * as fs from "node:fs";
-import * as os from "node:os";
-import * as path4 from "node:path";
 // ../package.json
 var package_default = {
   name: "context-dropper",
-  version: "0.1.5",
+  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",
@@ -12376,30 +12372,304 @@ var package_default = {
 // ../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({
+      body: {
+        service,
+        level,
+        message: msg,
+        ...extra !== undefined ? { extra } : {}
+      }
+    }).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 SessionManager {
-  sessionStates = new Map;
-  sessionPruneMap = new Map;
-  setSession(sessionId, state) {
-    this.sessionStates.set(sessionId, state);
+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;
   }
-  getSession(sessionId) {
-    return this.sessionStates.get(sessionId);
+  async initDropper() {
+    await this.dropper.create();
   }
-  deleteSession(sessionId) {
-    this.sessionStates.delete(sessionId);
-    this.sessionPruneMap.delete(sessionId);
+  async getCurrentFile() {
+    return this.dropper.getCurrentFile();
   }
-  setPruneMessageId(sessionId, messageId) {
-    this.sessionPruneMap.set(sessionId, messageId);
+  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>`;
   }
-  getPruneMessageId(sessionId) {
-    return this.sessionPruneMap.get(sessionId);
+  async tagProcessed() {
+    return this.dropper.tagProcessed();
+  }
+  async isDone() {
+    return this.dropper.isDone();
+  }
+  async nextFile() {
+    return this.dropper.nextFile();
+  }
+  get dropperName() {
+    return this.dropper.dropperName;
   }
 }
 
-// src/toolkit.ts
-import path3 from "node:path";
+class SessionManager {
+  dropperService;
+  sessions = new Map;
+  log;
+  cwd;
+  constructor(cwd, log, dropperService) {
+    this.dropperService = dropperService;
+    this.cwd = cwd;
+    this.log = log;
+  }
+  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.sessions.get(sessionId);
+  }
+  deleteSession(sessionId) {
+    this.log(`Deleting session ${sessionId}`);
+    this.sessions.delete(sessionId);
+  }
+}
 
 // ../src/dropper/service.ts
 import {
@@ -12411,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 {
@@ -12481,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);
@@ -12751,408 +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;
-  constructor(cwd, dropperService, filesetService) {
-    this.dropperService = dropperService ?? new DefaultDropperService;
-    this.filesetService = filesetService ?? new DefaultFilesetService;
-    this.dataDir = path3.resolve(cwd, ".context-dropper");
-  }
-  async createDropper(filesetName, dropperName) {
-    await this.dropperService.create({
-      dataDir: this.dataDir,
-      filesetName,
-      dropperName
-    });
-  }
-  async removeDropper(dropperName) {
-    try {
-      await this.dropperService.remove({
-        dataDir: this.dataDir,
-        dropperName
-      });
-    } catch (e) {
-      if (e.message && e.message.includes("not found")) {
-        return;
+// src/index.ts
+class Program {
+  sessionManager;
+  log;
+  messageHandler;
+  constructor(sessionManager, log) {
+    this.sessionManager = sessionManager;
+    this.log = log;
+    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) {
-    await this.dropperService.tag({
-      dataDir: this.dataDir,
-      dropperName,
-      tags: ["processed"]
     });
   }
-  async isDone(dropperName) {
-    try {
-      await this.dropperService.isDone({
-        dataDir: this.dataDir,
-        dropperName
-      });
-      return true;
-    } catch (e) {
-      return false;
-    }
-  }
-  async nextFile(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.`;
-  }
-}
-
-// src/index.ts
-var opencodeDir = path4.join(os.homedir(), ".opencode");
-if (!fs.existsSync(opencodeDir)) {
-  fs.mkdirSync(opencodeDir, { recursive: true });
-}
-var logFile = path4.join(opencodeDir, "context-dropper.log");
-var MAX_LOG_SIZE_BYTES = 10 * 1024 * 1024;
-var log = (msg, ...args) => {
-  const timestamp = new Date().toISOString();
-  const formattedArgs = args.length > 0 ? " " + args.map((a) => typeof a === "object" ? JSON.stringify(a) : a).join(" ") : "";
-  const logMessage = `[${timestamp}] [ContextDropper] ${msg}${formattedArgs}
-`;
-  console.error(`[ContextDropper] ${msg}`, ...args);
-  try {
-    if (fs.existsSync(logFile)) {
-      const stats = fs.statSync(logFile);
-      if (stats.size >= MAX_LOG_SIZE_BYTES) {
-        const content = fs.readFileSync(logFile, "utf-8");
-        const keepLength = Math.floor(content.length / 2);
-        const rotatedContent = content.slice(-keepLength);
-        const firstNewlineIndex = rotatedContent.indexOf(`
-`);
-        const cleanContent = firstNewlineIndex !== -1 ? rotatedContent.slice(firstNewlineIndex + 1) : rotatedContent;
-        fs.writeFileSync(logFile, cleanContent);
-      }
-    }
-    fs.appendFileSync(logFile, logMessage);
-  } catch (e) {
-    console.error("Failed to write/rotate plugin log file", e);
+  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);
   }
-};
-var sessionManager = new SessionManager;
-var toolkit = new Toolkit(process.cwd());
-var ContextDropperPlugin = async (ctx) => {
-  const version2 = getPackageVersion();
-  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", e));
-    log("Initialization toast sent");
-  }, 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 {
-            log(`Removing existing dropper ${dropperName}`);
-            await toolkit.removeDropper(dropperName);
-            log(`Creating dropper ${dropperName} from fileset ${args.filesetName}`);
-            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: ${error45.message}`);
-            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 {
-            log(`Tagging ${state.dropperName} current file as 'processed'`);
-            await toolkit.tagProcessed(state.dropperName);
-            log(`Checking if ${state.dropperName} is done`);
-            const isDone = await toolkit.isDone(state.dropperName);
+            await session.tagProcessed();
+            const isDone = await session.isDone();
             if (isDone) {
-              log(`Session ${state.dropperName} completed.`);
-              sessionManager.deleteSession(sessionId);
+              this.log(`Session completed`, {
+                dropperName: session.dropperName
+              });
+              this.sessionManager.deleteSession(sessionId);
               return `[Context-Dropper: All files have been processed. Task complete.]`;
             }
-            log(`Advancing to next file in ${state.dropperName}`);
-            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: ${error45.message}`);
-            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 in session ${sessionId}. Starts with /drop? ${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 {
-                log(`Removing existing dropper ${dropperName}`);
-                await toolkit.removeDropper(dropperName);
-                log(`Creating dropper ${dropperName} from fileset ${filesetName}`);
-                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: ${error45.message}`);
-                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 index = output.messages.findIndex((m) => m.info && m.info.id === pruneStartId);
-        if (index !== -1) {
-          output.messages.splice(0, index);
-        }
+    };
+  }
+  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.5",
+  "version": "0.2.0",
   "description": "A Context Dropper plugin for OpenCode that automates file iteration context management.",
   "author": {
     "name": "Fardjad Davari",