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

package/dist/index.js

@@ -1342,18 +1342,18 @@ var require_papaparse = __commonJS((exports, module) => {
 
 // node_modules/convert-csv-to-json/src/util/fileUtils.js
 var require_fileUtils = __commonJS((exports, module) => {
-  var fs8 = __require("fs");
+  var fs9 = __require("fs");
 
   class FileUtils {
     readFile(fileInputName, encoding) {
-      return fs8.readFileSync(fileInputName, encoding).toString();
+      return fs9.readFileSync(fileInputName, encoding).toString();
     }
     readFileAsync(fileInputName, encoding = "utf8") {
-      if (fs8.promises && typeof fs8.promises.readFile === "function") {
-        return fs8.promises.readFile(fileInputName, encoding).then((buf) => buf.toString());
+      if (fs9.promises && typeof fs9.promises.readFile === "function") {
+        return fs9.promises.readFile(fileInputName, encoding).then((buf) => buf.toString());
       }
       return new Promise((resolve2, reject) => {
-        fs8.readFile(fileInputName, encoding, (err, data) => {
+        fs9.readFile(fileInputName, encoding, (err, data) => {
           if (err) {
             reject(err);
             return;
@@ -1363,7 +1363,7 @@ var require_fileUtils = __commonJS((exports, module) => {
       });
     }
     writeFile(json3, fileOutputName) {
-      fs8.writeFile(fileOutputName, json3, function(err) {
+      fs9.writeFile(fileOutputName, json3, function(err) {
         if (err) {
           throw err;
         } else {
@@ -1372,11 +1372,11 @@ var require_fileUtils = __commonJS((exports, module) => {
       });
     }
     writeFileAsync(json3, fileOutputName) {
-      if (fs8.promises && typeof fs8.promises.writeFile === "function") {
-        return fs8.promises.writeFile(fileOutputName, json3);
+      if (fs9.promises && typeof fs9.promises.writeFile === "function") {
+        return fs9.promises.writeFile(fileOutputName, json3);
       }
       return new Promise((resolve2, reject) => {
-        fs8.writeFile(fileOutputName, json3, (err) => {
+        fs9.writeFile(fileOutputName, json3, (err) => {
           if (err)
             return reject(err);
           resolve2();
@@ -1941,7 +1941,7 @@ var require_convert_csv_to_json = __commonJS((exports) => {
 });
 
 // src/index.ts
-import { dirname as dirname5, join as join10 } from "path";
+import { dirname as dirname6, join as join13 } from "path";
 import { fileURLToPath } from "url";
 
 // src/utils/agentLoader.ts
@@ -17273,8 +17273,8 @@ var fetch_currency_prices_default = tool({
   }
 });
 // src/tools/classify-statements.ts
-import * as fs5 from "fs";
-import * as path6 from "path";
+import * as fs6 from "fs";
+import * as path7 from "path";
 
 // src/utils/importConfig.ts
 import * as fs3 from "fs";
@@ -17543,6 +17543,63 @@ function detectProvider(filename, content, config2) {
 
 // src/utils/worktreeManager.ts
 import { spawnSync } from "child_process";
+
+// node_modules/uuid/dist-node/stringify.js
+var byteToHex = [];
+for (let i2 = 0;i2 < 256; ++i2) {
+  byteToHex.push((i2 + 256).toString(16).slice(1));
+}
+function unsafeStringify(arr, offset = 0) {
+  return (byteToHex[arr[offset + 0]] + byteToHex[arr[offset + 1]] + byteToHex[arr[offset + 2]] + byteToHex[arr[offset + 3]] + "-" + byteToHex[arr[offset + 4]] + byteToHex[arr[offset + 5]] + "-" + byteToHex[arr[offset + 6]] + byteToHex[arr[offset + 7]] + "-" + byteToHex[arr[offset + 8]] + byteToHex[arr[offset + 9]] + "-" + byteToHex[arr[offset + 10]] + byteToHex[arr[offset + 11]] + byteToHex[arr[offset + 12]] + byteToHex[arr[offset + 13]] + byteToHex[arr[offset + 14]] + byteToHex[arr[offset + 15]]).toLowerCase();
+}
+
+// node_modules/uuid/dist-node/rng.js
+import { randomFillSync } from "crypto";
+var rnds8Pool = new Uint8Array(256);
+var poolPtr = rnds8Pool.length;
+function rng() {
+  if (poolPtr > rnds8Pool.length - 16) {
+    randomFillSync(rnds8Pool);
+    poolPtr = 0;
+  }
+  return rnds8Pool.slice(poolPtr, poolPtr += 16);
+}
+
+// node_modules/uuid/dist-node/native.js
+import { randomUUID } from "crypto";
+var native_default = { randomUUID };
+
+// node_modules/uuid/dist-node/v4.js
+function _v4(options, buf, offset) {
+  options = options || {};
+  const rnds = options.random ?? options.rng?.() ?? rng();
+  if (rnds.length < 16) {
+    throw new Error("Random bytes length must be >= 16");
+  }
+  rnds[6] = rnds[6] & 15 | 64;
+  rnds[8] = rnds[8] & 63 | 128;
+  if (buf) {
+    offset = offset || 0;
+    if (offset < 0 || offset + 16 > buf.length) {
+      throw new RangeError(`UUID byte range ${offset}:${offset + 15} is out of buffer bounds`);
+    }
+    for (let i2 = 0;i2 < 16; ++i2) {
+      buf[offset + i2] = rnds[i2];
+    }
+    return buf;
+  }
+  return unsafeStringify(rnds);
+}
+function v4(options, buf, offset) {
+  if (native_default.randomUUID && !buf && !options) {
+    return native_default.randomUUID();
+  }
+  return _v4(options, buf, offset);
+}
+var v4_default = v4;
+// src/utils/worktreeManager.ts
+import * as fs4 from "fs";
+import * as path5 from "path";
 function execGit(args, cwd) {
   const result = spawnSync("git", args, { cwd, encoding: "utf-8" });
   if (result.status !== 0) {
@@ -17550,6 +17607,92 @@ function execGit(args, cwd) {
   }
   return (result.stdout || "").trim();
 }
+function execGitSafe(args, cwd) {
+  const result = spawnSync("git", args, { cwd, encoding: "utf-8" });
+  if (result.status !== 0) {
+    return { success: false, output: result.stderr || result.stdout || `git ${args[0]} failed` };
+  }
+  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();
+  const branch = `import-${uuid3}`;
+  const worktreePath = path5.join(baseDir, `import-worktree-${uuid3}`);
+  try {
+    execGit(["rev-parse", "--git-dir"], mainRepoPath);
+  } catch {
+    throw new Error(`Not a git repository: ${mainRepoPath}`);
+  }
+  execGit(["branch", branch], mainRepoPath);
+  try {
+    execGit(["worktree", "add", worktreePath, branch], mainRepoPath);
+  } catch (error45) {
+    execGitSafe(["branch", "-D", branch], mainRepoPath);
+    throw error45;
+  }
+  copyIncomingFiles(mainRepoPath, worktreePath);
+  return {
+    path: worktreePath,
+    branch,
+    uuid: uuid3,
+    mainRepoPath
+  };
+}
+function mergeWorktree(context, commitMessage) {
+  const status = execGit(["status", "--porcelain"], context.path);
+  if (status.length > 0) {
+    execGit(["add", "-A"], context.path);
+    execGit(["commit", "-m", commitMessage], context.path);
+  }
+  const currentBranch = execGit(["rev-parse", "--abbrev-ref", "HEAD"], context.mainRepoPath);
+  execGit(["merge", "--no-ff", context.branch, "-m", commitMessage], context.mainRepoPath);
+  if (currentBranch !== "main" && currentBranch !== "master") {
+    execGit(["checkout", currentBranch], context.mainRepoPath);
+  }
+}
+function removeWorktree(context, force = false) {
+  const forceFlag = force ? "--force" : "";
+  const args = ["worktree", "remove", context.path];
+  if (forceFlag) {
+    args.push(forceFlag);
+  }
+  const removeResult = execGitSafe(args, context.mainRepoPath);
+  if (!removeResult.success) {
+    if (!fs4.existsSync(context.path)) {} else {
+      return { success: false, error: `Failed to remove worktree: ${removeResult.output}` };
+    }
+  }
+  execGitSafe(["worktree", "prune"], context.mainRepoPath);
+  const branchResult = execGitSafe(["branch", "-D", context.branch], context.mainRepoPath);
+  if (!branchResult.success) {
+    if (!branchResult.output.includes("not found")) {
+      return { success: false, error: `Failed to delete branch: ${branchResult.output}` };
+    }
+  }
+  return { success: true };
+}
 function isInWorktree(directory) {
   try {
     const gitDir = execGit(["rev-parse", "--git-dir"], directory);
@@ -17558,22 +17701,34 @@ function isInWorktree(directory) {
     return false;
   }
 }
+async function withWorktree(directory, operation) {
+  let createdWorktree = null;
+  try {
+    createdWorktree = createImportWorktree(directory);
+    const result = await operation(createdWorktree);
+    return result;
+  } finally {
+    if (createdWorktree) {
+      removeWorktree(createdWorktree, true);
+    }
+  }
+}
 
 // src/utils/fileUtils.ts
-import * as fs4 from "fs";
-import * as path5 from "path";
+import * as fs5 from "fs";
+import * as path6 from "path";
 function findCSVFiles(importsDir) {
-  if (!fs4.existsSync(importsDir)) {
+  if (!fs5.existsSync(importsDir)) {
     return [];
   }
-  return fs4.readdirSync(importsDir).filter((file2) => file2.toLowerCase().endsWith(".csv")).filter((file2) => {
-    const fullPath = path5.join(importsDir, file2);
-    return fs4.statSync(fullPath).isFile();
+  return fs5.readdirSync(importsDir).filter((file2) => file2.toLowerCase().endsWith(".csv")).filter((file2) => {
+    const fullPath = path6.join(importsDir, file2);
+    return fs5.statSync(fullPath).isFile();
   });
 }
 function ensureDirectory(dirPath) {
-  if (!fs4.existsSync(dirPath)) {
-    fs4.mkdirSync(dirPath, { recursive: true });
+  if (!fs5.existsSync(dirPath)) {
+    fs5.mkdirSync(dirPath, { recursive: true });
   }
 }
 
@@ -17614,20 +17769,20 @@ function planMoves(csvFiles, importsDir, pendingDir, unrecognizedDir, config2) {
   const plannedMoves = [];
   const collisions = [];
   for (const filename of csvFiles) {
-    const sourcePath = path6.join(importsDir, filename);
-    const content = fs5.readFileSync(sourcePath, "utf-8");
+    const sourcePath = path7.join(importsDir, filename);
+    const content = fs6.readFileSync(sourcePath, "utf-8");
     const detection = detectProvider(filename, content, config2);
     let targetPath;
     let targetFilename;
     if (detection) {
       targetFilename = detection.outputFilename || filename;
-      const targetDir = path6.join(pendingDir, detection.provider, detection.currency);
-      targetPath = path6.join(targetDir, targetFilename);
+      const targetDir = path7.join(pendingDir, detection.provider, detection.currency);
+      targetPath = path7.join(targetDir, targetFilename);
     } else {
       targetFilename = filename;
-      targetPath = path6.join(unrecognizedDir, filename);
+      targetPath = path7.join(unrecognizedDir, filename);
     }
-    if (fs5.existsSync(targetPath)) {
+    if (fs6.existsSync(targetPath)) {
       collisions.push({
         filename,
         existingPath: targetPath
@@ -17648,22 +17803,22 @@ function executeMoves(plannedMoves, config2, unrecognizedDir) {
   const unrecognized = [];
   for (const move of plannedMoves) {
     if (move.detection) {
-      const targetDir = path6.dirname(move.targetPath);
+      const targetDir = path7.dirname(move.targetPath);
       ensureDirectory(targetDir);
-      fs5.renameSync(move.sourcePath, move.targetPath);
+      fs6.renameSync(move.sourcePath, move.targetPath);
       classified.push({
         filename: move.targetFilename,
         originalFilename: move.detection.outputFilename ? move.filename : undefined,
         provider: move.detection.provider,
         currency: move.detection.currency,
-        targetPath: path6.join(config2.paths.pending, move.detection.provider, move.detection.currency, move.targetFilename)
+        targetPath: path7.join(config2.paths.pending, move.detection.provider, move.detection.currency, move.targetFilename)
       });
     } else {
       ensureDirectory(unrecognizedDir);
-      fs5.renameSync(move.sourcePath, move.targetPath);
+      fs6.renameSync(move.sourcePath, move.targetPath);
       unrecognized.push({
         filename: move.filename,
-        targetPath: path6.join(config2.paths.unrecognized, move.filename)
+        targetPath: path7.join(config2.paths.unrecognized, move.filename)
       });
     }
   }
@@ -17687,9 +17842,9 @@ async function classifyStatements(directory, agent, configLoader = loadImportCon
     const errorMessage = err instanceof Error ? err.message : String(err);
     return buildErrorResult2(errorMessage);
   }
-  const importsDir = path6.join(directory, config2.paths.import);
-  const pendingDir = path6.join(directory, config2.paths.pending);
-  const unrecognizedDir = path6.join(directory, config2.paths.unrecognized);
+  const importsDir = path7.join(directory, config2.paths.import);
+  const pendingDir = path7.join(directory, config2.paths.pending);
+  const unrecognizedDir = path7.join(directory, config2.paths.unrecognized);
   const csvFiles = findCSVFiles(importsDir);
   if (csvFiles.length === 0) {
     return buildSuccessResult2([], [], `No CSV files found in ${config2.paths.import}`);
@@ -17710,12 +17865,12 @@ var classify_statements_default = tool({
   }
 });
 // src/tools/import-statements.ts
-import * as fs9 from "fs";
-import * as path8 from "path";
+import * as fs10 from "fs";
+import * as path9 from "path";
 
 // src/utils/rulesMatcher.ts
-import * as fs6 from "fs";
-import * as path7 from "path";
+import * as fs7 from "fs";
+import * as path8 from "path";
 function parseSourceDirective(content) {
   const match = content.match(/^source\s+([^\n#]+)/m);
   if (!match) {
@@ -17724,28 +17879,28 @@ function parseSourceDirective(content) {
   return match[1].trim();
 }
 function resolveSourcePath(sourcePath, rulesFilePath) {
-  if (path7.isAbsolute(sourcePath)) {
+  if (path8.isAbsolute(sourcePath)) {
     return sourcePath;
   }
-  const rulesDir = path7.dirname(rulesFilePath);
-  return path7.resolve(rulesDir, sourcePath);
+  const rulesDir = path8.dirname(rulesFilePath);
+  return path8.resolve(rulesDir, sourcePath);
 }
 function loadRulesMapping(rulesDir) {
   const mapping = {};
-  if (!fs6.existsSync(rulesDir)) {
+  if (!fs7.existsSync(rulesDir)) {
     return mapping;
   }
-  const files = fs6.readdirSync(rulesDir);
+  const files = fs7.readdirSync(rulesDir);
   for (const file2 of files) {
     if (!file2.endsWith(".rules")) {
       continue;
     }
-    const rulesFilePath = path7.join(rulesDir, file2);
-    const stat = fs6.statSync(rulesFilePath);
+    const rulesFilePath = path8.join(rulesDir, file2);
+    const stat = fs7.statSync(rulesFilePath);
     if (!stat.isFile()) {
       continue;
     }
-    const content = fs6.readFileSync(rulesFilePath, "utf-8");
+    const content = fs7.readFileSync(rulesFilePath, "utf-8");
     const sourcePath = parseSourceDirective(content);
     if (!sourcePath) {
       continue;
@@ -17759,9 +17914,9 @@ function findRulesForCsv(csvPath, mapping) {
   if (mapping[csvPath]) {
     return mapping[csvPath];
   }
-  const normalizedCsvPath = path7.normalize(csvPath);
+  const normalizedCsvPath = path8.normalize(csvPath);
   for (const [mappedCsv, rulesFile] of Object.entries(mapping)) {
-    if (path7.normalize(mappedCsv) === normalizedCsvPath) {
+    if (path8.normalize(mappedCsv) === normalizedCsvPath) {
       return rulesFile;
     }
   }
@@ -17887,7 +18042,7 @@ async function getAccountBalance(mainJournalPath, account, asOfDate, executor =
 }
 
 // src/utils/rulesParser.ts
-import * as fs7 from "fs";
+import * as fs8 from "fs";
 function parseSkipRows(rulesContent) {
   const match = rulesContent.match(/^skip\s+(\d+)/m);
   return match ? parseInt(match[1], 10) : 0;
@@ -17953,7 +18108,7 @@ function parseAccount1(rulesContent) {
 }
 function getAccountFromRulesFile(rulesFilePath) {
   try {
-    const content = fs7.readFileSync(rulesFilePath, "utf-8");
+    const content = fs8.readFileSync(rulesFilePath, "utf-8");
     return parseAccount1(content);
   } catch {
     return null;
@@ -17973,7 +18128,7 @@ function parseRulesFile(rulesContent) {
 
 // src/utils/csvParser.ts
 var import_convert_csv_to_json = __toESM(require_convert_csv_to_json(), 1);
-import * as fs8 from "fs";
+import * as fs9 from "fs";
 
 // src/utils/balanceUtils.ts
 function parseAmountValue(amountStr) {
@@ -18022,7 +18177,7 @@ function balancesMatch(balance1, balance2) {
 
 // src/utils/csvParser.ts
 function parseCsvFile(csvPath, config2) {
-  const csvContent = fs8.readFileSync(csvPath, "utf-8");
+  const csvContent = fs9.readFileSync(csvPath, "utf-8");
   const lines = csvContent.split(`
 `);
   const headerIndex = config2.skipRows;
@@ -18182,8 +18337,8 @@ function buildSuccessResult3(files, summary, message) {
 async function executeImports(fileResults, directory, pendingDir, doneDir, hledgerExecutor) {
   const importedFiles = [];
   for (const fileResult of fileResults) {
-    const csvFile = path8.join(directory, fileResult.csv);
-    const rulesFile = fileResult.rulesFile ? path8.join(directory, fileResult.rulesFile) : null;
+    const csvFile = path9.join(directory, fileResult.csv);
+    const rulesFile = fileResult.rulesFile ? path9.join(directory, fileResult.rulesFile) : null;
     if (!rulesFile)
       continue;
     const year = fileResult.transactionYear;
@@ -18219,7 +18374,7 @@ async function executeImports(fileResults, directory, pendingDir, doneDir, hledg
     }
     importedFiles.push(csvFile);
   }
-  const mainJournalPath = path8.join(directory, ".hledger.journal");
+  const mainJournalPath = path9.join(directory, ".hledger.journal");
   const validationResult = await validateLedger(mainJournalPath, hledgerExecutor);
   if (!validationResult.valid) {
     return {
@@ -18229,13 +18384,13 @@ async function executeImports(fileResults, directory, pendingDir, doneDir, hledg
     };
   }
   for (const csvFile of importedFiles) {
-    const relativePath = path8.relative(pendingDir, csvFile);
-    const destPath = path8.join(doneDir, relativePath);
-    const destDir = path8.dirname(destPath);
-    if (!fs9.existsSync(destDir)) {
-      fs9.mkdirSync(destDir, { recursive: true });
+    const relativePath = path9.relative(pendingDir, csvFile);
+    const destPath = path9.join(doneDir, relativePath);
+    const destDir = path9.dirname(destPath);
+    if (!fs10.existsSync(destDir)) {
+      fs10.mkdirSync(destDir, { recursive: true });
     }
-    fs9.renameSync(csvFile, destPath);
+    fs10.renameSync(csvFile, destPath);
   }
   return {
     success: true,
@@ -18246,7 +18401,7 @@ async function processCsvFile(csvFile, rulesMapping, directory, hledgerExecutor)
   const rulesFile = findRulesForCsv(csvFile, rulesMapping);
   if (!rulesFile) {
     return {
-      csv: path8.relative(directory, csvFile),
+      csv: path9.relative(directory, csvFile),
       rulesFile: null,
       totalTransactions: 0,
       matchedTransactions: 0,
@@ -18257,8 +18412,8 @@ async function processCsvFile(csvFile, rulesMapping, directory, hledgerExecutor)
   const result = await hledgerExecutor(["print", "-f", csvFile, "--rules-file", rulesFile]);
   if (result.exitCode !== 0) {
     return {
-      csv: path8.relative(directory, csvFile),
-      rulesFile: path8.relative(directory, rulesFile),
+      csv: path9.relative(directory, csvFile),
+      rulesFile: path9.relative(directory, rulesFile),
       totalTransactions: 0,
       matchedTransactions: 0,
       unknownPostings: [],
@@ -18272,8 +18427,8 @@ async function processCsvFile(csvFile, rulesMapping, directory, hledgerExecutor)
   if (years.size > 1) {
     const yearList = Array.from(years).sort().join(", ");
     return {
-      csv: path8.relative(directory, csvFile),
-      rulesFile: path8.relative(directory, rulesFile),
+      csv: path9.relative(directory, csvFile),
+      rulesFile: path9.relative(directory, rulesFile),
       totalTransactions: transactionCount,
       matchedTransactions: matchedCount,
       unknownPostings: [],
@@ -18283,7 +18438,7 @@ async function processCsvFile(csvFile, rulesMapping, directory, hledgerExecutor)
   const transactionYear = years.size === 1 ? Array.from(years)[0] : undefined;
   if (unknownPostings.length > 0) {
     try {
-      const rulesContent = fs9.readFileSync(rulesFile, "utf-8");
+      const rulesContent = fs10.readFileSync(rulesFile, "utf-8");
       const rulesConfig = parseRulesFile(rulesContent);
       const csvRows = parseCsvFile(csvFile, rulesConfig);
       for (const posting of unknownPostings) {
@@ -18300,8 +18455,8 @@ async function processCsvFile(csvFile, rulesMapping, directory, hledgerExecutor)
     }
   }
   return {
-    csv: path8.relative(directory, csvFile),
-    rulesFile: path8.relative(directory, rulesFile),
+    csv: path9.relative(directory, csvFile),
+    rulesFile: path9.relative(directory, rulesFile),
     totalTransactions: transactionCount,
     matchedTransactions: matchedCount,
     unknownPostings,
@@ -18323,9 +18478,9 @@ async function importStatements(directory, agent, options, configLoader = loadIm
     const errorMessage = `Failed to load configuration: ${error45 instanceof Error ? error45.message : String(error45)}`;
     return buildErrorResult3(errorMessage, 'Ensure config/import/providers.yaml exists with required paths including "rules"');
   }
-  const pendingDir = path8.join(directory, config2.paths.pending);
-  const rulesDir = path8.join(directory, config2.paths.rules);
-  const doneDir = path8.join(directory, config2.paths.done);
+  const pendingDir = path9.join(directory, config2.paths.pending);
+  const rulesDir = path9.join(directory, config2.paths.rules);
+  const doneDir = path9.join(directory, config2.paths.done);
   const rulesMapping = loadRulesMapping(rulesDir);
   const csvFiles = findCsvFiles(pendingDir, options.provider, options.currency);
   if (csvFiles.length === 0) {
@@ -18450,8 +18605,8 @@ This tool processes CSV files in the pending import directory and uses hledger's
   }
 });
 // src/tools/reconcile-statement.ts
-import * as fs10 from "fs";
-import * as path9 from "path";
+import * as fs11 from "fs";
+import * as path10 from "path";
 function buildErrorResult4(params) {
   return JSON.stringify({
     success: false,
@@ -18499,14 +18654,14 @@ function findCsvToReconcile(doneDir, options) {
     };
   }
   const csvFile = csvFiles[csvFiles.length - 1];
-  const relativePath = path9.relative(path9.dirname(path9.dirname(doneDir)), csvFile);
+  const relativePath = path10.relative(path10.dirname(path10.dirname(doneDir)), csvFile);
   return { csvFile, relativePath };
 }
 function determineClosingBalance(csvFile, config2, options, relativeCsvPath) {
   let metadata;
   try {
-    const content = fs10.readFileSync(csvFile, "utf-8");
-    const filename = path9.basename(csvFile);
+    const content = fs11.readFileSync(csvFile, "utf-8");
+    const filename = path10.basename(csvFile);
     const detectionResult = detectProvider(filename, content, config2);
     metadata = detectionResult?.metadata;
   } catch {
@@ -18514,9 +18669,10 @@ function determineClosingBalance(csvFile, config2, options, relativeCsvPath) {
   }
   let closingBalance = options.closingBalance;
   if (!closingBalance && metadata?.closing_balance) {
-    closingBalance = metadata.closing_balance;
-    if (metadata.currency && !closingBalance.includes(metadata.currency)) {
-      closingBalance = `${metadata.currency} ${closingBalance}`;
+    const { closing_balance, currency } = metadata;
+    closingBalance = closing_balance;
+    if (currency && !closingBalance.includes(currency)) {
+      closingBalance = `${currency} ${closingBalance}`;
     }
   }
   if (!closingBalance) {
@@ -18555,7 +18711,7 @@ function determineAccount(csvFile, rulesDir, options, relativeCsvPath, metadata)
   }
   return { account };
 }
-async function reconcileStatementCore(directory, agent, options, configLoader = loadImportConfig, hledgerExecutor = defaultHledgerExecutor, worktreeChecker = isInWorktree) {
+async function reconcileStatement(directory, agent, options, configLoader = loadImportConfig, hledgerExecutor = defaultHledgerExecutor, worktreeChecker = isInWorktree) {
   const restrictionError = checkAccountantAgent(agent, "reconcile statement");
   if (restrictionError) {
     return restrictionError;
@@ -18569,9 +18725,9 @@ async function reconcileStatementCore(directory, agent, options, configLoader =
     return configResult.error;
   }
   const { config: config2 } = configResult;
-  const doneDir = path9.join(directory, config2.paths.done);
-  const rulesDir = path9.join(directory, config2.paths.rules);
-  const mainJournalPath = path9.join(directory, ".hledger.journal");
+  const doneDir = path10.join(directory, config2.paths.done);
+  const rulesDir = path10.join(directory, config2.paths.rules);
+  const mainJournalPath = path10.join(directory, ".hledger.journal");
   const csvResult = findCsvToReconcile(doneDir, options);
   if ("error" in csvResult) {
     return csvResult.error;
@@ -18686,7 +18842,7 @@ It must be run inside an import worktree (use import-pipeline for the full workf
   },
   async execute(params, context) {
     const { directory, agent } = context;
-    return reconcileStatementCore(directory, agent, {
+    return reconcileStatement(directory, agent, {
       provider: params.provider,
       currency: params.currency,
       closingBalance: params.closingBalance,
@@ -18694,9 +18850,416 @@ 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");
+    this.name = "NoTransactionsError";
+  }
+}
+function buildStepResult(success2, message, details) {
+  const result = { success: success2, message };
+  if (details !== undefined) {
+    result.details = details;
+  }
+  return result;
+}
+function buildSuccessResult5(result, summary) {
+  result.success = true;
+  result.summary = summary;
+  return JSON.stringify(result);
+}
+function buildErrorResult5(result, error45, hint) {
+  result.success = false;
+  result.error = error45;
+  if (hint) {
+    result.hint = hint;
+  }
+  return JSON.stringify(result);
+}
+function buildCommitMessage(provider, currency, fromDate, untilDate, transactionCount) {
+  const providerStr = provider?.toUpperCase() || "statements";
+  const currencyStr = currency?.toUpperCase();
+  const dateRange = fromDate && untilDate ? ` ${fromDate} to ${untilDate}` : "";
+  const txStr = transactionCount > 0 ? ` (${transactionCount} transactions)` : "";
+  const parts = ["Import:", providerStr];
+  if (currencyStr) {
+    parts.push(currencyStr);
+  }
+  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)");
+    return;
+  }
+  const inWorktree = () => true;
+  const classifyResult = await classifyStatements(worktree.path, context.agent, context.configLoader, inWorktree);
+  const classifyParsed = JSON.parse(classifyResult);
+  const success2 = classifyParsed.success !== false;
+  let message = success2 ? "Classification complete" : "Classification had issues";
+  if (classifyParsed.unrecognized?.length > 0) {
+    message = `Classification complete with ${classifyParsed.unrecognized.length} unrecognized file(s)`;
+  }
+  const details = {
+    success: success2,
+    unrecognized: classifyParsed.unrecognized,
+    classified: classifyParsed
+  };
+  context.result.steps.classify = buildStepResult(success2, message, details);
+}
+async function executeDryRunStep(context, worktree) {
+  const inWorktree = () => true;
+  const dryRunResult = await importStatements(worktree.path, context.agent, {
+    provider: context.options.provider,
+    currency: context.options.currency,
+    checkOnly: true
+  }, context.configLoader, context.hledgerExecutor, inWorktree);
+  const dryRunParsed = JSON.parse(dryRunResult);
+  const message = dryRunParsed.success ? `Dry run passed: ${dryRunParsed.summary?.totalTransactions || 0} transactions ready` : `Dry run failed: ${dryRunParsed.summary?.unknown || 0} unknown account(s)`;
+  context.result.steps.dryRun = buildStepResult(dryRunParsed.success, message, {
+    success: dryRunParsed.success,
+    summary: dryRunParsed.summary
+  });
+  if (!dryRunParsed.success) {
+    context.result.error = "Dry run found unknown accounts or errors";
+    context.result.hint = "Add rules to categorize unknown transactions, then retry";
+    throw new Error("Dry run failed");
+  }
+  if (dryRunParsed.summary?.totalTransactions === 0) {
+    throw new NoTransactionsError;
+  }
+}
+async function executeImportStep(context, worktree) {
+  const inWorktree = () => true;
+  const importResult = await importStatements(worktree.path, context.agent, {
+    provider: context.options.provider,
+    currency: context.options.currency,
+    checkOnly: false
+  }, context.configLoader, context.hledgerExecutor, inWorktree);
+  const importParsed = JSON.parse(importResult);
+  const message = importParsed.success ? `Imported ${importParsed.summary?.totalTransactions || 0} transactions` : `Import failed: ${importParsed.error || "Unknown error"}`;
+  context.result.steps.import = buildStepResult(importParsed.success, message, {
+    success: importParsed.success,
+    summary: importParsed.summary,
+    error: importParsed.error
+  });
+  if (!importParsed.success) {
+    context.result.error = `Import failed: ${importParsed.error || "Unknown error"}`;
+    throw new Error("Import failed");
+  }
+}
+async function executeReconcileStep(context, worktree) {
+  const inWorktree = () => true;
+  const reconcileResult = await reconcileStatement(worktree.path, context.agent, {
+    provider: context.options.provider,
+    currency: context.options.currency,
+    closingBalance: context.options.closingBalance,
+    account: context.options.account
+  }, context.configLoader, context.hledgerExecutor, inWorktree);
+  const reconcileParsed = JSON.parse(reconcileResult);
+  const message = reconcileParsed.success ? `Balance reconciled: ${reconcileParsed.actualBalance}` : `Balance mismatch: expected ${reconcileParsed.expectedBalance}, got ${reconcileParsed.actualBalance}`;
+  context.result.steps.reconcile = buildStepResult(reconcileParsed.success, message, {
+    success: reconcileParsed.success,
+    actualBalance: reconcileParsed.actualBalance,
+    expectedBalance: reconcileParsed.expectedBalance,
+    metadata: reconcileParsed.metadata,
+    error: reconcileParsed.error
+  });
+  if (!reconcileParsed.success) {
+    context.result.error = `Reconciliation failed: ${reconcileParsed.error || "Balance mismatch"}`;
+    context.result.hint = "Check for missing transactions or incorrect rules";
+    throw new Error("Reconciliation failed");
+  }
+}
+async function executeMergeStep(context, worktree) {
+  const importDetails = context.result.steps.import?.details;
+  const reconcileDetails = context.result.steps.reconcile?.details;
+  if (!importDetails || !reconcileDetails) {
+    throw new Error("Import or reconcile step not completed before merge");
+  }
+  const commitInfo = {
+    fromDate: reconcileDetails.metadata?.from_date,
+    untilDate: reconcileDetails.metadata?.until_date
+  };
+  const transactionCount = importDetails.summary?.totalTransactions || 0;
+  const commitMessage = buildCommitMessage(context.options.provider, context.options.currency, commitInfo.fromDate, commitInfo.untilDate, transactionCount);
+  try {
+    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);
+    context.result.error = "Merge to main branch failed";
+    throw new Error("Merge failed");
+  }
+}
+function handleNoTransactions(result) {
+  result.steps.import = buildStepResult(true, "No transactions to import");
+  result.steps.reconcile = buildStepResult(true, "Reconciliation skipped (no transactions)");
+  result.steps.merge = buildStepResult(true, "Merge skipped (no changes)");
+  return buildSuccessResult5(result, "No transactions found to import");
+}
+async function importPipeline(directory, agent, options, configLoader = loadImportConfig, hledgerExecutor = defaultHledgerExecutor) {
+  const restrictionError = checkAccountantAgent(agent, "import pipeline");
+  if (restrictionError) {
+    return restrictionError;
+  }
+  const result = {
+    success: false,
+    steps: {}
+  };
+  const context = {
+    directory,
+    agent,
+    options,
+    configLoader,
+    hledgerExecutor,
+    result
+  };
+  try {
+    return await withWorktree(directory, async (worktree) => {
+      result.worktreeId = worktree.uuid;
+      result.steps.worktree = buildStepResult(true, `Created worktree at ${worktree.path}`, {
+        path: worktree.path,
+        branch: worktree.branch
+      });
+      try {
+        await executeClassifyStep(context, worktree);
+        await executeDryRunStep(context, worktree);
+        await executeImportStep(context, worktree);
+        await executeReconcileStep(context, worktree);
+        await executeMergeStep(context, worktree);
+        result.steps.cleanup = buildStepResult(true, "Worktree cleaned up", {
+          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 });
+        if (error45 instanceof NoTransactionsError) {
+          return handleNoTransactions(result);
+        }
+        if (!result.error) {
+          result.error = error45 instanceof Error ? error45.message : String(error45);
+        }
+        return buildErrorResult5(result, result.error, result.hint);
+      }
+    });
+  } catch (error45) {
+    result.steps.worktree = buildStepResult(false, `Failed to create worktree: ${error45 instanceof Error ? error45.message : String(error45)}`);
+    result.error = "Failed to create worktree";
+    return buildErrorResult5(result, result.error);
+  }
+}
+var import_pipeline_default = tool({
+  description: `ACCOUNTANT AGENT ONLY: Complete import pipeline with git worktree isolation and balance reconciliation.
+
+This tool orchestrates the full import workflow in an isolated git worktree:
+
+**Pipeline Steps:**
+1. **Create Worktree**: Creates an isolated git worktree for safe import
+2. **Classify**: Moves CSVs from import to pending directory (optional, skip with skipClassify)
+3. **Dry Run**: Validates all transactions have known accounts
+4. **Import**: Imports transactions to the journal
+5. **Reconcile**: Validates closing balance matches CSV metadata
+6. **Merge**: Merges worktree to main with --no-ff
+7. **Cleanup**: Removes worktree
+
+**Safety Features:**
+- All changes happen in isolated worktree
+- If any step fails, worktree is discarded (main branch untouched)
+- Balance reconciliation ensures data integrity
+- Atomic commit with merge --no-ff preserves history
+
+**Usage:**
+- Basic: import-pipeline (processes all pending CSVs)
+- Filtered: import-pipeline --provider ubs --currency chf
+- With manual balance: import-pipeline --closingBalance "CHF 1234.56"
+- Skip classify: import-pipeline --skipClassify true`,
+  args: {
+    provider: tool.schema.string().optional().describe('Filter by provider (e.g., "ubs", "revolut")'),
+    currency: tool.schema.string().optional().describe('Filter by currency (e.g., "chf", "eur")'),
+    closingBalance: tool.schema.string().optional().describe("Manual closing balance override (if not in CSV metadata)"),
+    account: tool.schema.string().optional().describe("Manual account override (auto-detected from rules file if not provided)"),
+    skipClassify: tool.schema.boolean().optional().describe("Skip the classify step (default: false)")
+  },
+  async execute(params, context) {
+    const { directory, agent } = context;
+    return importPipeline(directory, agent, {
+      provider: params.provider,
+      currency: params.currency,
+      closingBalance: params.closingBalance,
+      account: params.account,
+      skipClassify: params.skipClassify
+    });
+  }
+});
+// 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 = dirname5(fileURLToPath(import.meta.url));
-var AGENT_FILE = join10(__dirname2, "..", "agent", "accountant.md");
+var __dirname2 = dirname6(fileURLToPath(import.meta.url));
+var AGENT_FILE = join13(__dirname2, "..", "agent", "accountant.md");
 var AccountantPlugin = async () => {
   const agent = loadAgent(AGENT_FILE);
   return {
@@ -18704,7 +19267,8 @@ var AccountantPlugin = async () => {
       "fetch-currency-prices": fetch_currency_prices_default,
       "classify-statements": classify_statements_default,
       "import-statements": import_statements_default,
-      "reconcile-statements": reconcile_statement_default
+      "reconcile-statements": reconcile_statement_default,
+      "import-piprline": import_pipeline_default
     },
     config: async (config2) => {
       if (agent) {

package/package.json

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