@fuzzle/opencode-accountant 0.0.4 → 0.0.5-next.1

package/README.md

@@ -12,6 +12,81 @@ An OpenCode accounting agent, specialized in double-entry-bookkepping with hledg
 
 <!-- Installation instructions go here -->
 
+## Configuration
+
+### Price Fetching Configuration
+
+The `update-prices` tool requires a configuration file to specify which currency pairs to fetch. Create a `config/prices.yaml` file in your project directory with the following structure:
+
+```yaml
+currencies:
+  BTC:
+    source: coinmarketcap
+    pair: BTC/CHF
+    file: btc-chf.journal
+    backfill_date: '2025-12-31'
+
+  EUR:
+    source: ecb
+    pair: EUR/CHF
+    file: eur-chf.journal
+    backfill_date: '2025-12-31'
+
+  USD:
+    source: yahoo
+    pair: USDCHF=X
+    file: usd-chf.journal
+    fmt_base: USD
+    backfill_date: '2025-06-01'
+```
+
+#### Configuration Options
+
+Each currency entry supports the following fields:
+
+| Field           | Required | Description                                                                |
+| --------------- | -------- | -------------------------------------------------------------------------- |
+| `source`        | Yes      | The pricehist data source (e.g., `coinmarketcap`, `ecb`, `yahoo`)          |
+| `pair`          | Yes      | The currency pair to fetch (e.g., `BTC/CHF`, `EUR/CHF`)                    |
+| `file`          | Yes      | Output filename in `ledger/currencies/` (e.g., `btc-chf.journal`)          |
+| `fmt_base`      | No       | Base currency format override for pricehist (e.g., `USD` for yahoo source) |
+| `backfill_date` | No       | Start date for backfill mode. Defaults to January 1st of the current year  |
+
+#### Directory Structure
+
+The plugin expects the following directory structure in your project:
+
+```
+your-project/
+├── config/
+│   └── prices.yaml      # Price fetching configuration
+└── ledger/
+    └── currencies/      # Where price journal files are written
+        ├── btc-chf.journal
+        ├── eur-chf.journal
+        └── usd-chf.journal
+```
+
+#### Base Currency
+
+The `pair` field determines the currency conversion. While the examples above use CHF as the base currency, you can use any currency supported by your price source:
+
+```yaml
+currencies:
+  BTC:
+    source: coinmarketcap
+    pair: BTC/EUR # Prices in EUR instead of CHF
+    file: btc-eur.journal
+```
+
+#### Available Data Sources
+
+The `source` field accepts any source supported by [pricehist](https://github.com/chrisberkhout/pricehist). Common sources include:
+
+- `coinmarketcap` - Cryptocurrency prices
+- `ecb` - European Central Bank exchange rates
+- `yahoo` - Yahoo Finance (use `fmt_base` for proper formatting)
+
 ## Development
 
 - `mise run build` - Build the module

package/dist/index.js

@@ -11,7 +11,7 @@ var __export = (target, all) => {
 };
 
 // src/index.ts
-import { dirname, join as join2 } from "path";
+import { dirname, join as join3 } from "path";
 import { fileURLToPath } from "url";
 
 // src/utils/agentLoader.ts
@@ -15048,22 +15048,99 @@ function tool(input) {
 tool.schema = exports_external;
 // src/tools/update-prices.ts
 var {$ } = globalThis.Bun;
-import * as path from "path";
+import * as path2 from "path";
+import * as fs2 from "fs";
+
+// src/utils/pricesConfig.ts
 import * as fs from "fs";
-var TICKERS = {
-  BTC: { source: "coinmarketcap", pair: "BTC/CHF", file: "btc-chf.journal" },
-  EUR: { source: "ecb", pair: "EUR/CHF", file: "eur-chf.journal" },
-  USD: { source: "yahoo", pair: "USDCHF=X", file: "usd-chf.journal", fmtBase: "USD" }
-};
+import * as path from "path";
+var CONFIG_FILE = "config/prices.yaml";
+var REQUIRED_CURRENCY_FIELDS = ["source", "pair", "file"];
+function getDefaultBackfillDate() {
+  const year = new Date().getFullYear();
+  return `${year}-01-01`;
+}
+function validateCurrencyConfig(name, config2) {
+  if (typeof config2 !== "object" || config2 === null) {
+    throw new Error(`Invalid config for currency '${name}': expected an object`);
+  }
+  const configObj = config2;
+  for (const field of REQUIRED_CURRENCY_FIELDS) {
+    if (typeof configObj[field] !== "string" || configObj[field] === "") {
+      throw new Error(`Invalid config for currency '${name}': missing required field '${field}'`);
+    }
+  }
+  return {
+    source: configObj.source,
+    pair: configObj.pair,
+    file: configObj.file,
+    fmt_base: typeof configObj.fmt_base === "string" ? configObj.fmt_base : undefined,
+    backfill_date: typeof configObj.backfill_date === "string" ? configObj.backfill_date : undefined
+  };
+}
+function loadPricesConfig(directory) {
+  const configPath = path.join(directory, CONFIG_FILE);
+  if (!fs.existsSync(configPath)) {
+    throw new Error(`Configuration file not found: ${CONFIG_FILE}. Please refer to the plugin's GitHub repository for setup instructions.`);
+  }
+  let parsed;
+  try {
+    const content = fs.readFileSync(configPath, "utf-8");
+    parsed = jsYaml.load(content);
+  } catch (err) {
+    if (err instanceof jsYaml.YAMLException) {
+      throw new Error(`Failed to parse ${CONFIG_FILE}: ${err.message}`);
+    }
+    throw err;
+  }
+  if (typeof parsed !== "object" || parsed === null) {
+    throw new Error(`Invalid config: ${CONFIG_FILE} must contain a YAML object`);
+  }
+  const parsedObj = parsed;
+  if (!parsedObj.currencies || typeof parsedObj.currencies !== "object") {
+    throw new Error(`Invalid config: 'currencies' section is required`);
+  }
+  const currenciesObj = parsedObj.currencies;
+  if (Object.keys(currenciesObj).length === 0) {
+    throw new Error(`Invalid config: 'currencies' section must contain at least one currency`);
+  }
+  const currencies = {};
+  for (const [name, config2] of Object.entries(currenciesObj)) {
+    currencies[name] = validateCurrencyConfig(name, config2);
+  }
+  return { currencies };
+}
+
+// src/tools/update-prices.ts
+async function defaultPriceFetcher(cmdArgs) {
+  const result = await $`pricehist ${cmdArgs}`.quiet();
+  return result.stdout.toString().trim();
+}
 function getYesterday() {
   const d = new Date;
   d.setDate(d.getDate() - 1);
   return d.toISOString().split("T")[0];
 }
+function parsePriceLine(line) {
+  const match = line.match(/^P (\d{4}-\d{2}-\d{2})(?: \d{2}:\d{2}:\d{2})? .+$/);
+  if (!match)
+    return null;
+  return {
+    date: match[1],
+    formattedLine: line
+  };
+}
+function filterPriceLinesByDateRange(priceLines, startDate, endDate) {
+  return priceLines.map(parsePriceLine).filter((parsed) => {
+    if (!parsed)
+      return false;
+    return parsed.date >= startDate && parsed.date <= endDate;
+  }).sort((a, b) => a.date.localeCompare(b.date)).map((parsed) => parsed.formattedLine);
+}
 function updateJournalWithPrices(journalPath, newPriceLines) {
   let existingLines = [];
-  if (fs.existsSync(journalPath)) {
-    existingLines = fs.readFileSync(journalPath, "utf-8").split(`
+  if (fs2.existsSync(journalPath)) {
+    existingLines = fs2.readFileSync(journalPath, "utf-8").split(`
 `).filter((line) => line.trim() !== "");
   }
   const priceMap = new Map;
@@ -15078,82 +15155,100 @@ function updateJournalWithPrices(journalPath, newPriceLines) {
       priceMap.set(date5, line);
   }
   const sortedLines = Array.from(priceMap.entries()).sort((a, b) => a[0].localeCompare(b[0])).map(([, line]) => line);
-  fs.writeFileSync(journalPath, sortedLines.join(`
+  fs2.writeFileSync(journalPath, sortedLines.join(`
 `) + `
 `);
 }
-var update_prices_default = tool({
-  description: "ACCOUNTANT AGENT ONLY: Fetches end-of-day prices for all tickers (BTC, EUR, USD in CHF) and appends them to the corresponding price journals.",
-  args: {
-    backfill: tool.schema.boolean().optional().describe("If true, fetch all available history from 2025-12-31")
-  },
-  async execute(params, context) {
-    const { directory, agent } = context;
-    const { backfill } = params;
-    if (agent !== "accountant") {
-      return JSON.stringify({
-        error: "This tool is restricted to the accountant agent only.",
-        hint: "Use: Task(subagent_type='accountant', prompt='update prices')",
-        caller: agent || "main assistant"
-      });
-    }
-    const endDate = getYesterday();
-    const startDate = backfill ? "2025-12-31" : endDate;
-    const results = [];
-    for (const [ticker, config2] of Object.entries(TICKERS)) {
-      try {
-        const cmdArgs = [
-          "fetch",
-          "-o",
-          "ledger",
-          "-s",
-          startDate,
-          "-e",
-          endDate,
-          config2.source,
-          config2.pair
-        ];
-        if (config2.fmtBase) {
-          cmdArgs.push("--fmt-base", config2.fmtBase);
-        }
-        const result = await $`pricehist ${cmdArgs}`.quiet();
-        const output = result.stdout.toString().trim();
-        const priceLines = output.split(`
+async function updatePricesCore(directory, agent, backfill, priceFetcher = defaultPriceFetcher, configLoader = loadPricesConfig) {
+  if (agent !== "accountant") {
+    return JSON.stringify({
+      error: "This tool is restricted to the accountant agent only.",
+      hint: "Use: Task(subagent_type='accountant', prompt='update prices')",
+      caller: agent || "main assistant"
+    });
+  }
+  let config2;
+  try {
+    config2 = configLoader(directory);
+  } catch (err) {
+    return JSON.stringify({
+      error: err instanceof Error ? err.message : String(err)
+    });
+  }
+  const endDate = getYesterday();
+  const defaultBackfillDate = getDefaultBackfillDate();
+  const results = [];
+  for (const [ticker, currencyConfig] of Object.entries(config2.currencies)) {
+    try {
+      const startDate = backfill ? currencyConfig.backfill_date || defaultBackfillDate : endDate;
+      const cmdArgs = [
+        "fetch",
+        "-o",
+        "ledger",
+        "-s",
+        startDate,
+        "-e",
+        endDate,
+        currencyConfig.source,
+        currencyConfig.pair
+      ];
+      if (currencyConfig.fmt_base) {
+        cmdArgs.push("--fmt-base", currencyConfig.fmt_base);
+      }
+      const output = await priceFetcher(cmdArgs);
+      const rawPriceLines = output.split(`
 `).filter((line) => line.startsWith("P "));
-        if (priceLines.length === 0) {
-          results.push({
-            ticker,
-            error: `No price lines in pricehist output: ${output}`
-          });
-          continue;
-        }
-        const journalPath = path.join(directory, "ledger", config2.file);
-        updateJournalWithPrices(journalPath, priceLines);
-        const latestPriceLine = priceLines[priceLines.length - 1];
+      if (rawPriceLines.length === 0) {
         results.push({
           ticker,
-          priceLine: latestPriceLine,
-          file: config2.file
+          error: `No price lines in pricehist output: ${output}`
         });
-      } catch (err) {
+        continue;
+      }
+      const priceLines = filterPriceLinesByDateRange(rawPriceLines, startDate, endDate);
+      if (priceLines.length === 0) {
         results.push({
           ticker,
-          error: String(err)
+          error: `No price data found within date range ${startDate} to ${endDate}`
         });
+        continue;
       }
+      const journalPath = path2.join(directory, "ledger", "currencies", currencyConfig.file);
+      updateJournalWithPrices(journalPath, priceLines);
+      const latestPriceLine = priceLines[priceLines.length - 1];
+      results.push({
+        ticker,
+        priceLine: latestPriceLine,
+        file: currencyConfig.file
+      });
+    } catch (err) {
+      results.push({
+        ticker,
+        error: String(err)
+      });
     }
-    return JSON.stringify({
-      success: results.every((r) => !("error" in r)),
-      startDate,
-      endDate,
-      backfill: !!backfill,
-      results
-    });
+  }
+  return JSON.stringify({
+    success: results.every((r) => !("error" in r)),
+    endDate,
+    backfill: !!backfill,
+    results
+  });
+}
+var update_prices_default = tool({
+  description: "ACCOUNTANT AGENT ONLY: Fetches end-of-day prices for all configured currencies (from config/prices.yaml) and appends them to the corresponding price journals in ledger/currencies/.",
+  args: {
+    backfill: tool.schema.boolean().optional().describe("If true, fetch history from each currency's configured backfill_date (or Jan 1 of current year if not specified)")
+  },
+  async execute(params, context) {
+    const { directory, agent } = context;
+    const { backfill } = params;
+    return updatePricesCore(directory, agent, backfill || false);
   }
 });
 // src/index.ts
 var __dirname2 = dirname(fileURLToPath(import.meta.url));
-var AGENT_FILE = join2(__dirname2, "..", "agent", "accountant.md");
+var AGENT_FILE = join3(__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.0.4",
+  "version": "0.0.5-next.1",
   "description": "An OpenCode accounting agent, specialized in double-entry-bookkepping with hledger",
   "author": {
     "name": "ali bengali",