@fuzzle/opencode-accountant 0.1.2 → 0.1.3-next.1

package/README.md

@@ -199,13 +199,15 @@ The `import-pipeline` tool provides an atomic, safe import workflow using git wo
 2. Run `import-pipeline` tool with optional provider/currency filters
 3. The tool automatically:
    - Creates an isolated git worktree
+   - Syncs CSV files from main repo to worktree
    - Classifies CSV files by provider/currency
    - Validates all transactions have matching rules
    - Imports transactions to the appropriate year journal
    - Reconciles closing balance (if available in CSV metadata)
    - Merges changes back to main branch with `--no-ff`
+   - Deletes processed CSV files from main repo's import/incoming
    - Cleans up the worktree
-4. If any step fails, the worktree is discarded and main branch remains untouched
+4. If any step fails, the worktree is discarded and main branch remains untouched (CSV files are preserved for retry)
 
 ### Statement Import
 

package/agent/accountant.md

@@ -56,10 +56,10 @@ When working with accounting tasks:
 
 You have access to specialized MCP tools that MUST be used for their designated tasks. Do NOT attempt to replicate their functionality with bash commands, direct hledger CLI calls, or manual file edits.
 
-| Tool              | Use For                                              | NEVER Do Instead                                          |
-| ----------------- | ---------------------------------------------------- | --------------------------------------------------------- |
-| `import-pipeline` | Full import workflow (classify → import → reconcile) | Manual file moves, `hledger import`, manual journal edits |
-| `fetch-currency-prices`   | Fetching exchange rates                              | `curl` to price APIs, manual price entries                |
+| Tool                    | Use For                                              | NEVER Do Instead                                          |
+| ----------------------- | ---------------------------------------------------- | --------------------------------------------------------- |
+| `import-pipeline`       | Full import workflow (classify → import → reconcile) | Manual file moves, `hledger import`, manual journal edits |
+| `fetch-currency-prices` | Fetching exchange rates                              | `curl` to price APIs, manual price entries                |
 
 These tools handle validation, deduplication, error checking, and file organization automatically. Bypassing them risks data corruption, duplicate transactions, and inconsistent state.
 
@@ -87,11 +87,13 @@ The `import-pipeline` tool provides an **atomic, safe workflow** using git workt
 1. **Prepare**: Drop CSV files into `{paths.import}` (configured in `config/import/providers.yaml`, default: `import/incoming`)
 2. **Run Pipeline**: Execute `import-pipeline` (optionally filter by `provider` and `currency`)
 3. **Automatic Processing**: The tool creates an isolated git worktree and:
+   - Syncs CSV files from main repo to worktree
    - Classifies CSV files by provider/currency
    - Validates all transactions have matching rules
    - Imports transactions to the appropriate year journal
    - Reconciles closing balance (if available in CSV metadata)
    - Merges changes back to main branch with `--no-ff`
+   - Deletes processed CSV files from main repo's import/incoming
    - Cleans up the worktree
 4. **Handle Failures**: If any step fails (e.g., unknown postings found):
    - Worktree is discarded, main branch remains untouched
@@ -134,12 +136,14 @@ The following are MCP tools available to you. Always call these tools directly -
 **Behavior:**
 
 1. Creates isolated git worktree
-2. Classifies CSV files (unless `skipClassify: true`)
-3. Validates all transactions have matching rules (dry run)
-4. Imports transactions to year journal
-5. Reconciles closing balance against CSV metadata or manual value
-6. Merges to main with `--no-ff` commit
-7. Cleans up worktree
+2. Syncs CSV files from main repo to worktree
+3. Classifies CSV files (unless `skipClassify: true`)
+4. Validates all transactions have matching rules (dry run)
+5. Imports transactions to year journal
+6. Reconciles closing balance against CSV metadata or manual value
+7. Merges to main with `--no-ff` commit
+8. Deletes processed CSV files from main repo's import/incoming
+9. Cleans up worktree
 
 **Output:** Returns step-by-step results with success/failure for each phase
 

package/dist/index.js

@@ -1941,7 +1941,7 @@ var require_convert_csv_to_json = __commonJS((exports) => {
 });
 
 // src/index.ts
-import { dirname as dirname6, join as join11 } from "path";
+import { dirname as dirname6, join as join13 } from "path";
 import { fileURLToPath } from "url";
 
 // src/utils/agentLoader.ts
@@ -17614,6 +17614,27 @@ function execGitSafe(args, cwd) {
   }
   return { success: true, output: (result.stdout || "").trim() };
 }
+function copyIncomingFiles(mainRepoPath, worktreePath) {
+  const sourceDir = path5.join(mainRepoPath, "import/incoming");
+  const targetDir = path5.join(worktreePath, "import/incoming");
+  if (!fs4.existsSync(sourceDir)) {
+    return;
+  }
+  fs4.mkdirSync(targetDir, { recursive: true });
+  const entries = fs4.readdirSync(sourceDir, { withFileTypes: true });
+  let copiedCount = 0;
+  for (const entry of entries) {
+    if (entry.isFile() && !entry.name.startsWith(".")) {
+      const srcPath = path5.join(sourceDir, entry.name);
+      const destPath = path5.join(targetDir, entry.name);
+      fs4.copyFileSync(srcPath, destPath);
+      copiedCount++;
+    }
+  }
+  if (copiedCount > 0) {
+    console.log(`[INFO] Copied ${copiedCount} file(s) from import/incoming/ to worktree`);
+  }
+}
 function createImportWorktree(mainRepoPath, options = {}) {
   const baseDir = options.baseDir ?? "/tmp";
   const uuid3 = v4_default();
@@ -17631,6 +17652,7 @@ function createImportWorktree(mainRepoPath, options = {}) {
     execGitSafe(["branch", "-D", branch], mainRepoPath);
     throw error45;
   }
+  copyIncomingFiles(mainRepoPath, worktreePath);
   return {
     path: worktreePath,
     branch,
@@ -17709,6 +17731,53 @@ function ensureDirectory(dirPath) {
     fs5.mkdirSync(dirPath, { recursive: true });
   }
 }
+function syncCSVFilesToWorktree(mainRepoPath, worktreePath, importDir) {
+  const result = {
+    synced: [],
+    errors: []
+  };
+  const mainImportDir = path6.join(mainRepoPath, importDir);
+  const worktreeImportDir = path6.join(worktreePath, importDir);
+  const csvFiles = findCSVFiles(mainImportDir);
+  if (csvFiles.length === 0) {
+    return result;
+  }
+  ensureDirectory(worktreeImportDir);
+  for (const file2 of csvFiles) {
+    try {
+      const sourcePath = path6.join(mainImportDir, file2);
+      const destPath = path6.join(worktreeImportDir, file2);
+      fs5.copyFileSync(sourcePath, destPath);
+      result.synced.push(file2);
+    } catch (error45) {
+      const errorMsg = error45 instanceof Error ? error45.message : String(error45);
+      result.errors.push({ file: file2, error: errorMsg });
+    }
+  }
+  return result;
+}
+function cleanupProcessedCSVFiles(mainRepoPath, importDir) {
+  const result = {
+    deleted: [],
+    errors: []
+  };
+  const mainImportDir = path6.join(mainRepoPath, importDir);
+  const csvFiles = findCSVFiles(mainImportDir);
+  if (csvFiles.length === 0) {
+    return result;
+  }
+  for (const file2 of csvFiles) {
+    try {
+      const filePath = path6.join(mainImportDir, file2);
+      fs5.unlinkSync(filePath);
+      result.deleted.push(file2);
+    } catch (error45) {
+      const errorMsg = error45 instanceof Error ? error45.message : String(error45);
+      result.errors.push({ file: file2, error: errorMsg });
+    }
+  }
+  return result;
+}
 
 // src/tools/classify-statements.ts
 function buildSuccessResult2(classified, unrecognized, message) {
@@ -18829,6 +18898,8 @@ It must be run inside an import worktree (use import-pipeline for the full workf
   }
 });
 // src/tools/import-pipeline.ts
+import * as fs12 from "fs";
+import * as path11 from "path";
 class NoTransactionsError extends Error {
   constructor() {
     super("No transactions to import");
@@ -18866,6 +18937,38 @@ function buildCommitMessage(provider, currency, fromDate, untilDate, transaction
   }
   return `${parts.join(" ")}${dateRange}${txStr}`;
 }
+function cleanupIncomingFiles(worktree, context) {
+  const incomingDir = path11.join(worktree.mainRepoPath, "import/incoming");
+  if (!fs12.existsSync(incomingDir)) {
+    return;
+  }
+  const importStep = context.result.steps.import;
+  if (!importStep?.success || !importStep.details) {
+    return;
+  }
+  const importResult = importStep.details;
+  if (!importResult.files || !Array.isArray(importResult.files)) {
+    return;
+  }
+  let deletedCount = 0;
+  for (const fileResult of importResult.files) {
+    if (!fileResult.csv)
+      continue;
+    const filename = path11.basename(fileResult.csv);
+    const filePath = path11.join(incomingDir, filename);
+    if (fs12.existsSync(filePath)) {
+      try {
+        fs12.unlinkSync(filePath);
+        deletedCount++;
+      } catch (error45) {
+        console.error(`[ERROR] Failed to delete ${filename}: ${error45 instanceof Error ? error45.message : String(error45)}`);
+      }
+    }
+  }
+  if (deletedCount > 0) {
+    console.log(`[INFO] Cleaned up ${deletedCount} file(s) from import/incoming/`);
+  }
+}
 async function executeClassifyStep(context, worktree) {
   if (context.options.skipClassify) {
     context.result.steps.classify = buildStepResult(true, "Classification skipped (skipClassify: true)");
@@ -18966,6 +19069,7 @@ async function executeMergeStep(context, worktree) {
     mergeWorktree(worktree, commitMessage);
     const mergeDetails = { commitMessage };
     context.result.steps.merge = buildStepResult(true, `Merged to main: "${commitMessage}"`, mergeDetails);
+    cleanupIncomingFiles(worktree, context);
   } catch (error45) {
     const message = `Merge failed: ${error45 instanceof Error ? error45.message : String(error45)}`;
     context.result.steps.merge = buildStepResult(false, message);
@@ -19003,19 +19107,67 @@ async function importPipeline(directory, agent, options, configLoader = loadImpo
         path: worktree.path,
         branch: worktree.branch
       });
+      try {
+        const config2 = configLoader(directory);
+        const syncResult = syncCSVFilesToWorktree(directory, worktree.path, config2.paths.import);
+        if (syncResult.synced.length === 0 && syncResult.errors.length === 0) {
+          result.steps.sync = buildStepResult(true, "No CSV files to sync", {
+            synced: []
+          });
+        } else if (syncResult.errors.length > 0) {
+          result.steps.sync = buildStepResult(true, `Synced ${syncResult.synced.length} file(s) with ${syncResult.errors.length} error(s)`, { synced: syncResult.synced, errors: syncResult.errors });
+        } else {
+          result.steps.sync = buildStepResult(true, `Synced ${syncResult.synced.length} CSV file(s) to worktree`, { synced: syncResult.synced });
+        }
+      } catch (error45) {
+        const errorMsg = error45 instanceof Error ? error45.message : String(error45);
+        result.steps.sync = buildStepResult(false, `Failed to sync CSV files: ${errorMsg}`, { synced: [], errors: [{ file: "unknown", error: errorMsg }] });
+      }
       try {
         await executeClassifyStep(context, worktree);
         await executeDryRunStep(context, worktree);
         await executeImportStep(context, worktree);
         await executeReconcileStep(context, worktree);
+        try {
+          const config2 = configLoader(directory);
+          const cleanupResult = cleanupProcessedCSVFiles(directory, config2.paths.import);
+          if (cleanupResult.deleted.length === 0 && cleanupResult.errors.length === 0) {
+            result.steps.cleanup = buildStepResult(true, "No CSV files to cleanup", { csvCleanup: { deleted: [] } });
+          } else if (cleanupResult.errors.length > 0) {
+            result.steps.cleanup = buildStepResult(true, `Deleted ${cleanupResult.deleted.length} CSV file(s) with ${cleanupResult.errors.length} error(s)`, {
+              csvCleanup: {
+                deleted: cleanupResult.deleted,
+                errors: cleanupResult.errors
+              }
+            });
+          } else {
+            result.steps.cleanup = buildStepResult(true, `Deleted ${cleanupResult.deleted.length} CSV file(s) from main repo`, { csvCleanup: { deleted: cleanupResult.deleted } });
+          }
+        } catch (error45) {
+          const errorMsg = error45 instanceof Error ? error45.message : String(error45);
+          result.steps.cleanup = buildStepResult(false, `Failed to cleanup CSV files: ${errorMsg}`, {
+            csvCleanup: {
+              deleted: [],
+              errors: [{ file: "unknown", error: errorMsg }]
+            }
+          });
+        }
         await executeMergeStep(context, worktree);
-        result.steps.cleanup = buildStepResult(true, "Worktree cleaned up", {
-          cleanedAfterSuccess: true
-        });
+        const existingCleanup = result.steps.cleanup;
+        if (existingCleanup) {
+          existingCleanup.message += ", worktree cleaned up";
+          existingCleanup.details = {
+            ...existingCleanup.details,
+            cleanedAfterSuccess: true
+          };
+        }
         const transactionCount = context.result.steps.import?.details?.summary?.totalTransactions || 0;
         return buildSuccessResult5(result, `Successfully imported ${transactionCount} transaction(s)`);
       } catch (error45) {
-        result.steps.cleanup = buildStepResult(true, "Worktree cleaned up after failure", { cleanedAfterFailure: true });
+        result.steps.cleanup = buildStepResult(true, "Worktree cleaned up after failure (CSV files preserved for retry)", {
+          cleanedAfterFailure: true,
+          csvCleanup: { deleted: [] }
+        });
         if (error45 instanceof NoTransactionsError) {
           return handleNoTransactions(result);
         }
@@ -19074,9 +19226,135 @@ This tool orchestrates the full import workflow in an isolated git worktree:
     });
   }
 });
+// src/tools/init-directories.ts
+import * as fs13 from "fs";
+import * as path12 from "path";
+async function initDirectories(directory) {
+  try {
+    const config2 = loadImportConfig(directory);
+    const directoriesCreated = [];
+    const gitkeepFiles = [];
+    const importBase = path12.join(directory, "import");
+    if (!fs13.existsSync(importBase)) {
+      fs13.mkdirSync(importBase, { recursive: true });
+      directoriesCreated.push("import");
+    }
+    const pathsToCreate = [
+      { key: "import", path: config2.paths.import },
+      { key: "pending", path: config2.paths.pending },
+      { key: "done", path: config2.paths.done },
+      { key: "unrecognized", path: config2.paths.unrecognized }
+    ];
+    for (const { path: dirPath } of pathsToCreate) {
+      const fullPath = path12.join(directory, dirPath);
+      if (!fs13.existsSync(fullPath)) {
+        fs13.mkdirSync(fullPath, { recursive: true });
+        directoriesCreated.push(dirPath);
+      }
+      const gitkeepPath = path12.join(fullPath, ".gitkeep");
+      if (!fs13.existsSync(gitkeepPath)) {
+        fs13.writeFileSync(gitkeepPath, "");
+        gitkeepFiles.push(path12.join(dirPath, ".gitkeep"));
+      }
+    }
+    const gitignorePath = path12.join(importBase, ".gitignore");
+    let gitignoreCreated = false;
+    if (!fs13.existsSync(gitignorePath)) {
+      const gitignoreContent = `# Ignore CSV/PDF files in temporary directories
+/incoming/*.csv
+/incoming/*.pdf
+/pending/**/*.csv
+/pending/**/*.pdf
+/unrecognized/**/*.csv
+/unrecognized/**/*.pdf
+
+# Track processed files in done/ (audit trail)
+# No ignore rule needed - tracked by default
+
+# Ignore temporary files
+*.tmp
+*.temp
+.DS_Store
+Thumbs.db
+`;
+      fs13.writeFileSync(gitignorePath, gitignoreContent);
+      gitignoreCreated = true;
+    }
+    const parts = [];
+    if (directoriesCreated.length > 0) {
+      parts.push(`Created ${directoriesCreated.length} director${directoriesCreated.length === 1 ? "y" : "ies"}`);
+    }
+    if (gitkeepFiles.length > 0) {
+      parts.push(`added ${gitkeepFiles.length} .gitkeep file${gitkeepFiles.length === 1 ? "" : "s"}`);
+    }
+    if (gitignoreCreated) {
+      parts.push("created .gitignore");
+    }
+    const message = parts.length > 0 ? `Import directory structure initialized: ${parts.join(", ")}` : "Import directory structure already exists (no changes needed)";
+    return {
+      success: true,
+      directoriesCreated,
+      gitkeepFiles,
+      gitignoreCreated,
+      message
+    };
+  } catch (error45) {
+    return {
+      success: false,
+      directoriesCreated: [],
+      gitkeepFiles: [],
+      gitignoreCreated: false,
+      error: error45 instanceof Error ? error45.message : String(error45),
+      message: "Failed to initialize import directory structure"
+    };
+  }
+}
+var init_directories_default = tool({
+  description: "ACCOUNTANT AGENT ONLY: Initialize the import directory structure needed for processing bank statements. Creates import/incoming, import/pending, import/done, and import/unrecognized directories with .gitkeep files and appropriate .gitignore rules. Reads directory paths from config/import/providers.yaml. Safe to run multiple times (idempotent).",
+  args: {},
+  async execute(_params, context) {
+    const restrictionError = checkAccountantAgent(context.agent, "init directories");
+    if (restrictionError) {
+      throw new Error(restrictionError);
+    }
+    const { directory } = context;
+    const result = await initDirectories(directory);
+    if (!result.success) {
+      return `Error: ${result.error}
+
+${result.message}`;
+    }
+    const output = [];
+    output.push(result.message || "");
+    if (result.directoriesCreated.length > 0) {
+      output.push(`
+Directories created:`);
+      for (const dir of result.directoriesCreated) {
+        output.push(`  - ${dir}`);
+      }
+    }
+    if (result.gitkeepFiles.length > 0) {
+      output.push(`
+.gitkeep files added:`);
+      for (const file2 of result.gitkeepFiles) {
+        output.push(`  - ${file2}`);
+      }
+    }
+    if (result.gitignoreCreated) {
+      output.push(`
+Created import/.gitignore with rules to:`);
+      output.push("  - Ignore CSV/PDF files in incoming/, pending/, unrecognized/");
+      output.push("  - Track processed files in done/ for audit trail");
+    }
+    output.push(`
+You can now drop CSV files into import/incoming/ and run import-pipeline.`);
+    return output.join(`
+`);
+  }
+});
 // src/index.ts
 var __dirname2 = dirname6(fileURLToPath(import.meta.url));
-var AGENT_FILE = join11(__dirname2, "..", "agent", "accountant.md");
+var AGENT_FILE = join13(__dirname2, "..", "agent", "accountant.md");
 var AccountantPlugin = async () => {
   const agent = loadAgent(AGENT_FILE);
   return {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fuzzle/opencode-accountant",
-  "version": "0.1.2",
+  "version": "0.1.3-next.1",
   "description": "An OpenCode accounting agent, specialized in double-entry-bookkepping with hledger",
   "author": {
     "name": "ali bengali",