@kansei-link/bantou 0.2.0

package/dist/adapters/yayoi-adapter.js

@@ -0,0 +1,181 @@
+// 弥生会計 (Yayoi) CSV adapter.
+//
+// Parses the 仕訳日記帳 CSV export format.
+//
+// 弥生 exports several CSV formats. This adapter handles the most common:
+//   Format A: 仕訳日記帳 (Journal Ledger) — full double-entry bookkeeping
+//   Format B: 簡易帳簿 (Simple Bookkeeping) — single-entry (個人事業主向け)
+//
+// Both formats are supported via header auto-detection.
+//
+// ⚠ Important: 弥生 defaults to Shift-JIS encoding.
+// Users must select UTF-8 when exporting:
+//   弥生 → ファイル → エクスポート → 文字コード → UTF-8
+/**
+ * 弥生 仕訳日記帳 Format A headers (full double-entry).
+ *
+ * Typical columns (order may vary):
+ *   識別フラグ, 伝票No., 決算, 取引日付, 借方勘定科目, 借方補助科目,
+ *   借方部門, 借方税区分, 借方金額, 借方税金額, 貸方勘定科目, 貸方補助科目,
+ *   貸方部門, 貸方税区分, 貸方金額, 貸方税金額, 摘要, 番号, 期日, タイプ, 生成元, 仕訳メモ
+ */
+const YAYOI_FULL_REQUIRED = ['取引日付', '借方勘定科目', '借方金額', '摘要'];
+const YAYOI_FULL_OPTIONAL = ['貸方勘定科目', '貸方金額', '借方税区分', '貸方税区分', '伝票No.', '仕訳メモ'];
+/**
+ * 弥生 簡易帳簿 Format B headers (single-entry, 個人事業主).
+ *
+ * Typical columns:
+ *   日付, 科目, 金額, 摘要, 取引先
+ */
+const YAYOI_SIMPLE_REQUIRED = ['日付', '科目', '金額', '摘要'];
+export class YayoiAdapter {
+    source = 'yayoi';
+    label = '弥生会計 CSV';
+    format = null;
+    detectFormat(headers) {
+        // Normalize: trim whitespace
+        const h = headers.map(s => s.trim());
+        // Check Format A (full double-entry)
+        if (YAYOI_FULL_REQUIRED.every(req => h.includes(req))) {
+            this.format = 'full';
+            return true;
+        }
+        // Check Format B (simple bookkeeping)
+        if (YAYOI_SIMPLE_REQUIRED.every(req => h.includes(req))) {
+            this.format = 'simple';
+            return true;
+        }
+        return false;
+    }
+    parseRow(row, rowNumber) {
+        if (this.format === 'full') {
+            return this.parseFullRow(row, rowNumber);
+        }
+        else if (this.format === 'simple') {
+            return this.parseSimpleRow(row, rowNumber);
+        }
+        return { transaction: null, skip_reason: 'Unknown 弥生 format' };
+    }
+    /**
+     * Parse Format A: 仕訳日記帳 (double-entry).
+     *
+     * Logic:
+     * - Uses 借方金額 as amount (expense side). If 0, uses 貸方金額 (income side).
+     * - Combines 摘要 + 仕訳メモ for the memo field.
+     * - Skips rows where 識別フラグ indicates non-transaction lines (headers, totals).
+     */
+    parseFullRow(row, rowNumber) {
+        // Skip non-transaction rows (識別フラグ: 2000=通常仕訳, 2100=決算仕訳)
+        const flag = row['識別フラグ']?.trim();
+        if (flag && !['2000', '2100', ''].includes(flag)) {
+            return { transaction: null, skip_reason: `識別フラグ=${flag} (非仕訳行)` };
+        }
+        // Parse date
+        const dateStr = row['取引日付']?.trim();
+        const date = this.parseDate(dateStr);
+        if (!date) {
+            return { transaction: null, skip_reason: `日付パース失敗: "${dateStr}"` };
+        }
+        // Parse amount: prefer 借方金額 (expense), fall back to 貸方金額 (income)
+        const debitAmount = this.parseAmount(row['借方金額']);
+        const creditAmount = this.parseAmount(row['貸方金額']);
+        const amount = debitAmount || creditAmount;
+        if (!amount || amount === 0) {
+            return { transaction: null, skip_reason: '金額が0またはパース失敗' };
+        }
+        // Build memo: 摘要 + 仕訳メモ (if present)
+        const tekiyou = row['摘要']?.trim() || '';
+        const memo_note = row['仕訳メモ']?.trim() || '';
+        const memo = memo_note ? `${tekiyou} ${memo_note}` : tekiyou;
+        if (!memo) {
+            return { transaction: null, skip_reason: '摘要が空' };
+        }
+        // Extract partner name from 摘要 if it contains a known pattern
+        // (弥生 doesn't have a dedicated partner column in Format A)
+        const partner_name = this.extractPartner(row);
+        return {
+            transaction: { amount, memo, date, partner_name },
+            skip_reason: null,
+        };
+    }
+    /**
+     * Parse Format B: 簡易帳簿 (single-entry).
+     */
+    parseSimpleRow(row, rowNumber) {
+        const dateStr = row['日付']?.trim();
+        const date = this.parseDate(dateStr);
+        if (!date) {
+            return { transaction: null, skip_reason: `日付パース失敗: "${dateStr}"` };
+        }
+        const amount = this.parseAmount(row['金額']);
+        if (!amount || amount === 0) {
+            return { transaction: null, skip_reason: '金額が0またはパース失敗' };
+        }
+        const memo = row['摘要']?.trim() || '';
+        if (!memo) {
+            return { transaction: null, skip_reason: '摘要が空' };
+        }
+        const partner_name = row['取引先']?.trim() || undefined;
+        return {
+            transaction: { amount, memo, date, partner_name },
+            skip_reason: null,
+        };
+    }
+    /**
+     * Parse date from various 弥生 formats:
+     *   - "2026/05/01" (Western calendar)
+     *   - "2026-05-01" (ISO)
+     *   - "R08/05/01" (和暦 令和)
+     *   - "H28/05/01" (和暦 平成)
+     * Returns ISO format "YYYY-MM-DD" or null.
+     */
+    parseDate(dateStr) {
+        if (!dateStr)
+            return null;
+        const s = dateStr.trim();
+        // Western calendar: "2026/05/01" or "2026-05-01"
+        const westernMatch = s.match(/^(\d{4})[\/\-](\d{1,2})[\/\-](\d{1,2})$/);
+        if (westernMatch) {
+            const [, y, m, d] = westernMatch;
+            return `${y}-${m.padStart(2, '0')}-${d.padStart(2, '0')}`;
+        }
+        // 和暦: "R08/05/01" (令和), "H28/05/01" (平成)
+        const warekiMatch = s.match(/^([RrHh])(\d{1,2})[\/\-](\d{1,2})[\/\-](\d{1,2})$/);
+        if (warekiMatch) {
+            const [, era, ey, m, d] = warekiMatch;
+            const eraYear = parseInt(ey);
+            let year;
+            if (era === 'R' || era === 'r') {
+                year = 2018 + eraYear; // 令和1年 = 2019
+            }
+            else {
+                year = 1988 + eraYear; // 平成1年 = 1989
+            }
+            return `${year}-${m.padStart(2, '0')}-${d.padStart(2, '0')}`;
+        }
+        return null;
+    }
+    /**
+     * Parse amount string, removing commas and handling negative values.
+     * "12,000" → 12000, "-3,000" → 3000 (absolute value for classification).
+     */
+    parseAmount(amountStr) {
+        if (!amountStr)
+            return 0;
+        const cleaned = amountStr.replace(/[,、￥¥\s]/g, '');
+        const num = parseInt(cleaned, 10);
+        return isNaN(num) ? 0 : Math.abs(num);
+    }
+    /**
+     * Try to extract partner name from 弥生 Format A.
+     * Format A doesn't have a dedicated partner column, but some users
+     * put the partner name in 借方補助科目 or 貸方補助科目.
+     */
+    extractPartner(row) {
+        // Check 借方補助科目 / 貸方補助科目
+        const debitSub = row['借方補助科目']?.trim();
+        const creditSub = row['貸方補助科目']?.trim();
+        return debitSub || creditSub || undefined;
+    }
+}
+//# sourceMappingURL=yayoi-adapter.js.map

package/dist/bin/freee-doctor.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=freee-doctor.d.ts.map

package/dist/bin/freee-doctor.js

@@ -0,0 +1,15 @@
+#!/usr/bin/env node
+// CLI entry for the freee connection doctor.
+//   npm run doctor:freee     (or: npx tsx src/bin/freee-doctor.ts)
+// Prints the diagnostic as JSON. NEVER prints the access token.
+import { runFreeeDoctor } from '../freee-doctor.js';
+runFreeeDoctor()
+    .then((report) => {
+    console.log(JSON.stringify(report, null, 2));
+    process.exit(report.ok ? 0 : 1);
+})
+    .catch((err) => {
+    console.error(JSON.stringify({ ok: false, error: err?.message ?? String(err) }, null, 2));
+    process.exit(1);
+});
+//# sourceMappingURL=freee-doctor.js.map

package/dist/classifier/claude-classifier.d.ts

@@ -0,0 +1,24 @@
+import { Transaction, ClassificationResult } from './types.js';
+export interface KeywordCategoryMeta {
+    id: string;
+    name_ja: string;
+    name_en?: string;
+    freee_account_code: number;
+    default_tax_code: number;
+    description?: string;
+}
+export declare class ClaudeClassifier {
+    private client;
+    private categories;
+    private categoryById;
+    private systemPrompt;
+    private model;
+    constructor(apiKey: string, categories: KeywordCategoryMeta[], model?: string);
+    classify(tx: Transaction): Promise<ClassificationResult>;
+    private buildSystemPrompt;
+    private buildUserPrompt;
+    private parseResponse;
+    private fallback;
+    getModel(): string;
+}
+//# sourceMappingURL=claude-classifier.d.ts.map

package/dist/classifier/claude-classifier.js

@@ -0,0 +1,154 @@
+// Stage 2 classifier: Claude API fallback.
+//
+// Used when Stage 1 keyword classifier returns no match. Sends transaction
+// to Claude Haiku (= cheap + fast) with the 14-category system prompt and
+// returns a classification with confidence (high/medium/low).
+//
+// Cost optimization:
+// - System prompt (= 14 categories + rules) uses prompt caching → ~90% cost
+//   reduction on repeated requests with same category context.
+// - Model defaults to Haiku 4.5 (cheap, fast, sufficient for classification).
+//   Override via CLAUDE_MODEL env var.
+// - max_tokens = 200 (= classification response is short JSON).
+//
+// Falls back to unclassified if API errors, rate limits, or response is invalid.
+import Anthropic from '@anthropic-ai/sdk';
+const DEFAULT_MODEL = process.env.CLAUDE_MODEL || 'claude-haiku-4-5';
+export class ClaudeClassifier {
+    client;
+    categories;
+    categoryById;
+    systemPrompt;
+    model;
+    constructor(apiKey, categories, model = DEFAULT_MODEL) {
+        if (!apiKey || apiKey.trim() === '') {
+            throw new Error('ANTHROPIC_API_KEY is required for Stage 2 classifier');
+        }
+        this.client = new Anthropic({ apiKey });
+        this.categories = categories;
+        this.categoryById = new Map(categories.map(c => [c.id, c]));
+        this.systemPrompt = this.buildSystemPrompt();
+        this.model = model;
+    }
+    async classify(tx) {
+        try {
+            const response = await this.client.messages.create({
+                model: this.model,
+                max_tokens: 200,
+                system: [
+                    {
+                        type: 'text',
+                        text: this.systemPrompt,
+                        cache_control: { type: 'ephemeral' }, // 90% cost reduction on warm cache
+                    },
+                ],
+                messages: [
+                    {
+                        role: 'user',
+                        content: this.buildUserPrompt(tx),
+                    },
+                ],
+            });
+            const text = response.content
+                .filter((block) => block.type === 'text')
+                .map(block => block.text)
+                .join('');
+            return this.parseResponse(text);
+        }
+        catch (err) {
+            return this.fallback(`Stage 2 API error: ${err?.message || String(err)}`);
+        }
+    }
+    buildSystemPrompt() {
+        const categoryList = this.categories.map(c => `- ${c.id} (${c.name_ja}): ${c.description || 'no description'}`).join('\n');
+        return `You are a Japanese tax accounting classifier. Classify business transactions into 1 of 14 categories.
+
+# Categories
+
+${categoryList}
+
+# Output format
+
+Return JSON only. No markdown, no explanation outside JSON:
+
+{
+  "category_id": "<one of the category ids above>",
+  "confidence": "high|medium|low",
+  "reasoning": "<one short sentence in Japanese, 50 chars max>"
+}
+
+# Confidence rules
+
+- **high**: Clear unambiguous match (e.g., "楽天モバイル ¥5,500" → communications obvious)
+- **medium**: Leans toward one but other plausible (e.g., 海外 SaaS amount that could be utilities OR communications)
+- **low**: 2+ categories equally plausible OR insufficient info
+
+# Japanese tax accounting rules
+
+- 飲食 ≤¥10,000 → meeting_meal (会議費)
+- 飲食 >¥10,000 → entertainment (交際費)
+- 海外 SaaS (Anthropic / OpenAI / GitHub / AWS / Cloudflare / etc.) → communications + tax_code 0 (国外取引)
+- 軽減税率 (8%): 食品 / 新聞定期購読 / 持ち帰り飲食
+- 標準税率 (10%): 店内飲食 / 通常物販 / 国内サービス
+- 給与 / 借入 / 社保 / 投資 / ATM出金 / 公共料金 → これらは別途 exclusion check で escalate されるので、 通常分類すべきではない (= ただし keyword match で対象外な場合のみ、 確信あれば salary / loan etc. でもOK)`;
+    }
+    buildUserPrompt(tx) {
+        return `Transaction:
+- amount: ${tx.amount} JPY
+- memo: ${tx.memo}
+- date: ${tx.date}
+- partner: ${tx.partner_name || '(unknown)'}
+
+Classify into 1 category. JSON only.`;
+    }
+    parseResponse(text) {
+        try {
+            // Extract JSON (= LLM sometimes wraps in markdown despite instructions)
+            const jsonMatch = text.match(/\{[\s\S]*?\}/);
+            if (!jsonMatch) {
+                return this.fallback('Stage 2 returned no JSON');
+            }
+            const parsed = JSON.parse(jsonMatch[0]);
+            if (typeof parsed.category_id !== 'string') {
+                return this.fallback('Stage 2 response missing category_id');
+            }
+            const cat = this.categoryById.get(parsed.category_id);
+            if (!cat) {
+                return this.fallback(`Stage 2 returned unknown category: ${parsed.category_id}`);
+            }
+            const confidence = parsed.confidence === 'high'
+                ? 'high'
+                : parsed.confidence === 'medium'
+                    ? 'medium'
+                    : 'low';
+            const reasoning = typeof parsed.reasoning === 'string'
+                ? parsed.reasoning.slice(0, 100)
+                : 'AI classification';
+            return {
+                classified: true,
+                category_id: cat.id,
+                category_name_ja: cat.name_ja,
+                freee_account_code: cat.freee_account_code,
+                tax_code: cat.default_tax_code,
+                confidence,
+                match_reason: `Stage 2 (${this.model}): ${reasoning}`,
+                classifier_version: `jp-tax-baseline-v1.0.0+claude/${this.model}`,
+            };
+        }
+        catch (err) {
+            return this.fallback(`Stage 2 parse error: ${err?.message || String(err)}`);
+        }
+    }
+    fallback(reason) {
+        return {
+            classified: false,
+            confidence: 'none',
+            match_reason: reason,
+            classifier_version: `jp-tax-baseline-v1.0.0+claude/${this.model}`,
+        };
+    }
+    getModel() {
+        return this.model;
+    }
+}
+//# sourceMappingURL=claude-classifier.js.map

package/dist/classifier/keyword-classifier.d.ts

@@ -0,0 +1,22 @@
+import { Transaction, ClassificationResult } from './types.js';
+export declare class KeywordClassifier {
+    private dict;
+    private dictFile;
+    constructor(dictFile?: string, dataDir?: string);
+    classify(tx: Transaction): ClassificationResult;
+    getVersion(): string;
+    getCategoriesCount(): number;
+    getKeywordsCount(): number;
+    /**
+     * Returns category metadata for Stage 2 Claude classifier construction.
+     */
+    getCategoriesMeta(): {
+        id: string;
+        name_ja: string;
+        name_en: string | undefined;
+        freee_account_code: number;
+        default_tax_code: number;
+        description: string | undefined;
+    }[];
+}
+//# sourceMappingURL=keyword-classifier.d.ts.map

package/dist/classifier/keyword-classifier.js

@@ -0,0 +1,124 @@
+// Stage 1 keyword classifier.
+//
+// Reads jp-tax-baseline-v1.json keyword dictionary and matches a transaction
+// against the 14 categories using substring search after normalization.
+//
+// Match algorithm:
+// 1. Normalize memo (= 全角→半角, lowercase, trim)
+// 2. For each category (top to bottom):
+//    a. Check amount threshold (min/max)
+//    b. Iterate keywords; first substring match wins category
+//    c. If matched but amount exceeds threshold_max, redirect to amount_overflow_category
+// 3. No match → return classified: false (= proceed to Stage 2)
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { normalizeMemo } from './normalize.js';
+import { findFirstMatchingKeyword } from './keyword-match.js';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+// Locate the data directory (= prefer env var, else relative to package)
+function defaultDataDir() {
+    const envDir = process.env.COCKPIT_DATA_DIR;
+    if (envDir)
+        return envDir;
+    // In dev: src/classifier/ → ../../../data
+    // In prod (dist/): dist/classifier/ → ../../../data
+    return path.resolve(__dirname, '../../../../data');
+}
+export class KeywordClassifier {
+    dict;
+    dictFile;
+    constructor(dictFile, dataDir) {
+        const dir = dataDir || defaultDataDir();
+        this.dictFile = dictFile || path.join(dir, 'keyword-dict', 'jp-tax-baseline-v1.json');
+        if (!fs.existsSync(this.dictFile)) {
+            throw new Error(`Keyword dictionary not found at ${this.dictFile}. ` +
+                `Set COCKPIT_DATA_DIR env var or place data files at the expected path.`);
+        }
+        const raw = fs.readFileSync(this.dictFile, 'utf8');
+        this.dict = JSON.parse(raw);
+        // Pre-normalize all keywords once
+        for (const cat of this.dict.categories) {
+            cat._normalized_keywords = cat.keywords.map(normalizeMemo);
+        }
+    }
+    classify(tx) {
+        const normalized = normalizeMemo(tx.memo);
+        for (const cat of this.dict.categories) {
+            // Check amount threshold (min)
+            if (cat.amount_threshold_min !== undefined && tx.amount < cat.amount_threshold_min) {
+                continue;
+            }
+            // Find matching keyword (ASCII = word boundary, CJK = substring)
+            const keywords = cat._normalized_keywords || [];
+            const matchedKeywordIdx = findFirstMatchingKeyword(normalized, keywords);
+            const matchedKeyword = matchedKeywordIdx >= 0 ? cat.keywords[matchedKeywordIdx] : undefined;
+            if (matchedKeywordIdx === -1)
+                continue;
+            // Check amount threshold (max) → redirect if needed
+            if (cat.amount_threshold_max !== undefined && tx.amount > cat.amount_threshold_max) {
+                if (cat.amount_overflow_category) {
+                    const redirectedCat = this.dict.categories.find(c => c.id === cat.amount_overflow_category);
+                    if (redirectedCat) {
+                        return {
+                            classified: true,
+                            category_id: redirectedCat.id,
+                            category_name_ja: redirectedCat.name_ja,
+                            freee_account_code: redirectedCat.freee_account_code,
+                            tax_code: redirectedCat.default_tax_code,
+                            confidence: 'high', // amount-redirect is deterministic
+                            matched_keyword: matchedKeyword,
+                            match_reason: `Matched "${matchedKeyword}" in "${cat.id}" but amount ${tx.amount} > ${cat.amount_threshold_max}, redirected to "${redirectedCat.id}"`,
+                            classifier_version: this.dict.version,
+                            amount_override_redirect: cat.id,
+                            special_pattern: redirectedCat.special_pattern,
+                        };
+                    }
+                }
+            }
+            // Normal match
+            return {
+                classified: true,
+                category_id: cat.id,
+                category_name_ja: cat.name_ja,
+                freee_account_code: cat.freee_account_code,
+                tax_code: cat.default_tax_code,
+                confidence: 'high',
+                matched_keyword: matchedKeyword,
+                match_reason: `Matched keyword "${matchedKeyword}" in category "${cat.id}"`,
+                classifier_version: this.dict.version,
+                special_pattern: cat.special_pattern,
+            };
+        }
+        return {
+            classified: false,
+            confidence: 'none',
+            match_reason: 'No keyword match in any category',
+            classifier_version: this.dict.version,
+        };
+    }
+    getVersion() {
+        return this.dict.version;
+    }
+    getCategoriesCount() {
+        return this.dict.categories.length;
+    }
+    getKeywordsCount() {
+        return this.dict.categories.reduce((sum, c) => sum + c.keywords.length, 0);
+    }
+    /**
+     * Returns category metadata for Stage 2 Claude classifier construction.
+     */
+    getCategoriesMeta() {
+        return this.dict.categories.map(c => ({
+            id: c.id,
+            name_ja: c.name_ja,
+            name_en: c.name_en,
+            freee_account_code: c.freee_account_code,
+            default_tax_code: c.default_tax_code,
+            description: c.description,
+        }));
+    }
+}
+//# sourceMappingURL=keyword-classifier.js.map

package/dist/classifier/keyword-match.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Test if a keyword matches in a normalized memo.
+ *
+ * For ASCII-only keywords (= "ANA", "Suica", "Amazon"): require word boundary.
+ *   - "ANA 機内食" → matches (= space boundary)
+ *   - "analytics" → no match (= mid-word)
+ *   - "ANA"      → matches (= start/end boundary)
+ *
+ * For non-ASCII keywords (= "新幹線", "コーヒー"): substring match.
+ *   - "新幹線のぞみ" → matches
+ *   - "新幹線" alone → matches
+ */
+export declare function keywordMatches(normalizedMemo: string, normalizedKeyword: string): boolean;
+/**
+ * Find first matching keyword from a pre-normalized list against a pre-normalized memo.
+ * Returns the index of the first match, or -1 if no match.
+ *
+ * Use this in classifier loops for efficient single-pass matching.
+ */
+export declare function findFirstMatchingKeyword(normalizedMemo: string, normalizedKeywords: string[]): number;
+//# sourceMappingURL=keyword-match.d.ts.map

package/dist/classifier/keyword-match.js

@@ -0,0 +1,57 @@
+// Smart keyword matcher that prevents English-keyword false positives.
+//
+// Problem (= discovered 2026-05-12):
+//   keyword "ANA" → substring match → "Posthog Cloud (= an analytics SaaS)"
+//   の "ana" に誤発火、 travel category に分類される。
+//
+// Fix:
+//   - ASCII-only keywords → word-boundary regex match
+//   - Japanese / CJK / mixed keywords → substring match (= 既存挙動)
+//
+// Word boundary regex (\b) only works for word chars (= [A-Za-z0-9_]),
+// not CJK. So we split by charset and use appropriate strategy.
+const ASCII_ONLY_RE = /^[\x00-\x7F]+$/;
+const REGEX_SPECIAL_RE = /[.*+?^${}()|[\]\\]/g;
+function escapeRegExp(s) {
+    return s.replace(REGEX_SPECIAL_RE, '\\$&');
+}
+/**
+ * Test if a keyword matches in a normalized memo.
+ *
+ * For ASCII-only keywords (= "ANA", "Suica", "Amazon"): require word boundary.
+ *   - "ANA 機内食" → matches (= space boundary)
+ *   - "analytics" → no match (= mid-word)
+ *   - "ANA"      → matches (= start/end boundary)
+ *
+ * For non-ASCII keywords (= "新幹線", "コーヒー"): substring match.
+ *   - "新幹線のぞみ" → matches
+ *   - "新幹線" alone → matches
+ */
+export function keywordMatches(normalizedMemo, normalizedKeyword) {
+    if (!normalizedKeyword)
+        return false;
+    if (ASCII_ONLY_RE.test(normalizedKeyword)) {
+        // ASCII keyword → word-boundary regex
+        const re = new RegExp(`\\b${escapeRegExp(normalizedKeyword)}\\b`, 'i');
+        return re.test(normalizedMemo);
+    }
+    else {
+        // CJK / mixed keyword → substring match (= original behavior)
+        return normalizedMemo.includes(normalizedKeyword);
+    }
+}
+/**
+ * Find first matching keyword from a pre-normalized list against a pre-normalized memo.
+ * Returns the index of the first match, or -1 if no match.
+ *
+ * Use this in classifier loops for efficient single-pass matching.
+ */
+export function findFirstMatchingKeyword(normalizedMemo, normalizedKeywords) {
+    for (let i = 0; i < normalizedKeywords.length; i++) {
+        if (keywordMatches(normalizedMemo, normalizedKeywords[i])) {
+            return i;
+        }
+    }
+    return -1;
+}
+//# sourceMappingURL=keyword-match.js.map

package/dist/classifier/normalize.d.ts

@@ -0,0 +1,3 @@
+export declare function normalizeMemo(input: string): string;
+export declare function normalizeKeywordList(keywords: string[]): string[];
+//# sourceMappingURL=normalize.d.ts.map

package/dist/classifier/normalize.js

@@ -0,0 +1,27 @@
+// Memo string normalization for keyword matching.
+//
+// Steps:
+// 1. 全角英数 → 半角
+// 2. 全角カナ → 半角カナ (optional, configurable)
+// 3. 大文字 → 小文字
+// 4. trim whitespace
+//
+// Used by both classifier and exclusion checker for consistent matching.
+export function normalizeMemo(input) {
+    if (!input)
+        return '';
+    let s = input;
+    // 全角英数 → 半角 (ASCII range 0x21-0x7E)
+    s = s.replace(/[Ａ-Ｚａ-ｚ０-９]/g, (ch) => String.fromCharCode(ch.charCodeAt(0) - 0xFEE0));
+    // 全角スペース → 半角スペース
+    s = s.replace(/　/g, ' ');
+    // 大文字 → 小文字
+    s = s.toLowerCase();
+    // Trim + collapse whitespace
+    s = s.replace(/\s+/g, ' ').trim();
+    return s;
+}
+export function normalizeKeywordList(keywords) {
+    return keywords.map(normalizeMemo);
+}
+//# sourceMappingURL=normalize.js.map

package/dist/classifier/two-stage-classifier.d.ts

@@ -0,0 +1,21 @@
+import { KeywordClassifier } from './keyword-classifier.js';
+import { ClaudeClassifier, KeywordCategoryMeta } from './claude-classifier.js';
+import { Transaction, ClassificationResult } from './types.js';
+export interface TwoStageResult extends ClassificationResult {
+    stage: 1 | 2 | 'unclassified';
+}
+export declare class TwoStageClassifier {
+    private stage1;
+    private stage2;
+    constructor(stage1: KeywordClassifier, stage2?: ClaudeClassifier | null);
+    classify(tx: Transaction): Promise<TwoStageResult>;
+    hasStage2(): boolean;
+    getStage1(): KeywordClassifier;
+    getStage2(): ClaudeClassifier | null;
+}
+/**
+ * Helper: extract category metadata from keyword dict for ClaudeClassifier construction.
+ * Reads from KeywordClassifier's internal data via a getCategories() method.
+ */
+export declare function extractCategoryMeta(classifier: KeywordClassifier): KeywordCategoryMeta[];
+//# sourceMappingURL=two-stage-classifier.d.ts.map