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

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,
@@ -17679,6 +17701,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 +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) {
@@ -18676,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;
@@ -18807,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,
@@ -18816,34 +18851,192 @@ 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 {};
+import * as fs12 from "fs";
+import * as path11 from "path";
+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}`;
+}
+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 importPipelineCore(directory, agent, options, configLoader = loadImportConfig, hledgerExecutor = defaultHledgerExecutor) {
+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;
@@ -18852,163 +19045,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 +19122,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,
@@ -19054,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.1-next.1",
+  "version": "0.1.2-next.1",
   "description": "An OpenCode accounting agent, specialized in double-entry-bookkepping with hledger",
   "author": {
     "name": "ali bengali",