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

package/dist/index.js

@@ -17679,6 +17679,18 @@ 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 fs5 from "fs";
@@ -18635,9 +18647,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) {
@@ -18676,7 +18689,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;
@@ -18807,7 +18820,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,
@@ -18816,34 +18829,157 @@ It must be run inside an import worktree (use import-pipeline for the full workf
   }
 });
 // src/tools/import-pipeline.ts
-function extractCommitInfo(reconcileResult) {
-  try {
-    const parsed = JSON.parse(reconcileResult);
-    return {
-      fromDate: parsed.metadata?.from_date,
-      untilDate: parsed.metadata?.until_date,
-      transactionCount: undefined
-    };
-  } catch {
-    return {};
+class NoTransactionsError extends Error {
+  constructor() {
+    super("No transactions to import");
+    this.name = "NoTransactionsError";
   }
 }
-function extractTransactionCount(importResult) {
-  try {
-    const parsed = JSON.parse(importResult);
-    return parsed.summary?.totalTransactions || 0;
-  } catch {
-    return 0;
+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 currencyStr = currency?.toUpperCase();
   const dateRange = fromDate && untilDate ? ` ${fromDate} to ${untilDate}` : "";
   const txStr = transactionCount > 0 ? ` (${transactionCount} transactions)` : "";
-  return `Import: ${providerStr} ${currencyStr}${dateRange}${txStr}`.trim();
+  const parts = ["Import:", providerStr];
+  if (currencyStr) {
+    parts.push(currencyStr);
+  }
+  return `${parts.join(" ")}${dateRange}${txStr}`;
 }
-async function importPipelineCore(directory, agent, options, configLoader = loadImportConfig, hledgerExecutor = defaultHledgerExecutor) {
+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);
+  } 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;
@@ -18852,163 +18988,47 @@ async function importPipelineCore(directory, agent, options, configLoader = load
     success: false,
     steps: {}
   };
-  let worktree = null;
+  const context = {
+    directory,
+    agent,
+    options,
+    configLoader,
+    hledgerExecutor,
+    result
+  };
   try {
-    try {
-      worktree = createImportWorktree(directory);
+    return await withWorktree(directory, async (worktree) => {
       result.worktreeId = worktree.uuid;
-      result.steps.worktree = {
-        success: true,
-        message: `Created worktree at ${worktree.path}`,
-        details: { path: worktree.path, branch: worktree.branch }
-      };
-    } catch (error45) {
-      result.steps.worktree = {
-        success: false,
-        message: `Failed to create worktree: ${error45 instanceof Error ? error45.message : String(error45)}`
-      };
-      throw new Error("Failed to create worktree");
-    }
-    const inWorktree = () => true;
-    if (!options.skipClassify) {
-      const classifyResult = await classifyStatements(worktree.path, agent, configLoader, inWorktree);
-      const classifyParsed = JSON.parse(classifyResult);
-      result.steps.classify = {
-        success: classifyParsed.success !== false,
-        message: classifyParsed.success !== false ? "Classification complete" : "Classification had issues",
-        details: classifyParsed
-      };
-      if (classifyParsed.unrecognized?.length > 0) {
-        result.steps.classify.message = `Classification complete with ${classifyParsed.unrecognized.length} unrecognized file(s)`;
-      }
-    } else {
-      result.steps.classify = {
-        success: true,
-        message: "Classification skipped (skipClassify: true)"
-      };
-    }
-    const dryRunResult = await importStatements(worktree.path, agent, {
-      provider: options.provider,
-      currency: options.currency,
-      checkOnly: true
-    }, configLoader, hledgerExecutor, inWorktree);
-    const dryRunParsed = JSON.parse(dryRunResult);
-    result.steps.dryRun = {
-      success: dryRunParsed.success,
-      message: dryRunParsed.success ? `Dry run passed: ${dryRunParsed.summary?.totalTransactions || 0} transactions ready` : `Dry run failed: ${dryRunParsed.summary?.unknown || 0} unknown account(s)`,
-      details: dryRunParsed
-    };
-    if (!dryRunParsed.success) {
-      result.error = "Dry run found unknown accounts or errors";
-      result.hint = "Add rules to categorize unknown transactions, then retry";
-      throw new Error("Dry run failed");
-    }
-    if (dryRunParsed.summary?.totalTransactions === 0) {
-      result.steps.import = {
-        success: true,
-        message: "No transactions to import"
-      };
-      result.steps.reconcile = {
-        success: true,
-        message: "Reconciliation skipped (no transactions)"
-      };
-      result.steps.merge = {
-        success: true,
-        message: "Merge skipped (no changes)"
-      };
-      result.success = true;
-      result.summary = "No transactions found to import";
-      removeWorktree(worktree, true);
-      result.steps.cleanup = {
-        success: true,
-        message: "Worktree cleaned up"
-      };
-      return JSON.stringify(result);
-    }
-    const importResult = await importStatements(worktree.path, agent, {
-      provider: options.provider,
-      currency: options.currency,
-      checkOnly: false
-    }, configLoader, hledgerExecutor, inWorktree);
-    const importParsed = JSON.parse(importResult);
-    result.steps.import = {
-      success: importParsed.success,
-      message: importParsed.success ? `Imported ${importParsed.summary?.totalTransactions || 0} transactions` : `Import failed: ${importParsed.error || "Unknown error"}`,
-      details: importParsed
-    };
-    if (!importParsed.success) {
-      result.error = `Import failed: ${importParsed.error || "Unknown error"}`;
-      throw new Error("Import failed");
-    }
-    const reconcileResult = await reconcileStatementCore(worktree.path, agent, {
-      provider: options.provider,
-      currency: options.currency,
-      closingBalance: options.closingBalance,
-      account: options.account
-    }, configLoader, hledgerExecutor, inWorktree);
-    const reconcileParsed = JSON.parse(reconcileResult);
-    result.steps.reconcile = {
-      success: reconcileParsed.success,
-      message: reconcileParsed.success ? `Balance reconciled: ${reconcileParsed.actualBalance}` : `Balance mismatch: expected ${reconcileParsed.expectedBalance}, got ${reconcileParsed.actualBalance}`,
-      details: reconcileParsed
-    };
-    if (!reconcileParsed.success) {
-      result.error = `Reconciliation failed: ${reconcileParsed.error || "Balance mismatch"}`;
-      result.hint = "Check for missing transactions or incorrect rules";
-      throw new Error("Reconciliation failed");
-    }
-    const commitInfo = extractCommitInfo(reconcileResult);
-    const transactionCount = extractTransactionCount(importResult);
-    const commitMessage = buildCommitMessage(options.provider, options.currency, commitInfo.fromDate, commitInfo.untilDate, transactionCount);
-    try {
-      mergeWorktree(worktree, commitMessage);
-      result.steps.merge = {
-        success: true,
-        message: `Merged to main: "${commitMessage}"`,
-        details: { commitMessage }
-      };
-    } catch (error45) {
-      result.steps.merge = {
-        success: false,
-        message: `Merge failed: ${error45 instanceof Error ? error45.message : String(error45)}`
-      };
-      result.error = "Merge to main branch failed";
-      throw new Error("Merge failed");
-    }
-    try {
-      removeWorktree(worktree, true);
-      result.steps.cleanup = {
-        success: true,
-        message: "Worktree cleaned up"
-      };
-    } catch (error45) {
-      result.steps.cleanup = {
-        success: false,
-        message: `Cleanup warning: ${error45 instanceof Error ? error45.message : String(error45)}`
-      };
-    }
-    result.success = true;
-    result.summary = `Successfully imported ${transactionCount} transaction(s)`;
-    return JSON.stringify(result);
-  } catch (error45) {
-    if (worktree) {
+      result.steps.worktree = buildStepResult(true, `Created worktree at ${worktree.path}`, {
+        path: worktree.path,
+        branch: worktree.branch
+      });
       try {
-        removeWorktree(worktree, true);
-        result.steps.cleanup = {
-          success: true,
-          message: "Worktree cleaned up after failure"
-        };
-      } catch (cleanupError) {
-        result.steps.cleanup = {
-          success: false,
-          message: `Cleanup failed: ${cleanupError instanceof Error ? cleanupError.message : String(cleanupError)}`
-        };
+        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);
       }
-    }
-    if (!result.error) {
-      result.error = error45 instanceof Error ? error45.message : String(error45);
-    }
-    return JSON.stringify(result);
+    });
+  } 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({
@@ -19045,7 +19065,7 @@ This tool orchestrates the full import workflow in an isolated git worktree:
   },
   async execute(params, context) {
     const { directory, agent } = context;
-    return importPipelineCore(directory, agent, {
+    return importPipeline(directory, agent, {
       provider: params.provider,
       currency: params.currency,
       closingBalance: params.closingBalance,

package/package.json

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