@fuzzle/opencode-accountant 0.1.2 → 0.1.3

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,
@@ -18829,6 +18851,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 +18890,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 +19022,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);
@@ -19074,9 +19131,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",
   "description": "An OpenCode accounting agent, specialized in double-entry-bookkepping with hledger",
   "author": {
     "name": "ali bengali",