@woladi/sortai 0.1.1 → 0.2.0

package/dist/commands/organize.js

@@ -0,0 +1,92 @@
+import path from 'node:path';
+import { existsSync } from 'node:fs';
+import chalk from 'chalk';
+import ora from 'ora';
+import { expandHome, loadConfig, configExists } from '../config.js';
+import { buildOrganizePlan } from '../organize/plan.js';
+import { executeMove } from '../organize/move.js';
+import { runWizard } from '../wizard/index.js';
+function renderPlan(plan, root) {
+    process.stdout.write(chalk.bold(`📋 Plan przenoszenia (${plan.moves.length} plików):\n\n`));
+    const maxShow = 50;
+    for (const m of plan.moves.slice(0, maxShow)) {
+        const from = path.relative(root, m.from);
+        const to = m.to;
+        const tag = m.primaryTag ? chalk.cyan(` [${m.primaryTag}]`) : chalk.gray(' [_unsorted]');
+        process.stdout.write(`  ${from}\n    → ${to}${tag}\n`);
+    }
+    if (plan.moves.length > maxShow) {
+        process.stdout.write(chalk.gray(`  … i ${plan.moves.length - maxShow} więcej\n`));
+    }
+    if (plan.skips.length > 0) {
+        process.stdout.write('\n' + chalk.gray(`Pominięte (${plan.skips.length}):\n`));
+        for (const s of plan.skips.slice(0, 10)) {
+            process.stdout.write(chalk.gray(`  ${path.relative(root, s.path)} — ${s.reason}\n`));
+        }
+        if (plan.skips.length > 10) {
+            process.stdout.write(chalk.gray(`  … i ${plan.skips.length - 10} więcej\n`));
+        }
+    }
+    if (plan.conflicts > 0) {
+        process.stdout.write('\n' + chalk.yellow(`⚠️  ${plan.conflicts} konfliktów nazw — dodano sufiksy _2, _3 itd.\n`));
+    }
+}
+export async function organizeCommand(folder, opts) {
+    if (!(await configExists(opts.config))) {
+        process.stdout.write(chalk.cyan('🪄 Brak configu — uruchamiam wizard…\n\n'));
+        await runWizard({ configPath: opts.config, folderHint: folder });
+        return;
+    }
+    const { config } = await loadConfig(opts.config);
+    const cfg = opts.target
+        ? { ...config, organize: { ...config.organize, target: opts.target, enabled: true } }
+        : config;
+    const root = path.resolve(expandHome(folder ?? cfg.scan.folder));
+    if (!existsSync(root)) {
+        process.stderr.write(chalk.red(`Folder nie istnieje: ${root}\n`));
+        process.exit(1);
+    }
+    process.stdout.write(chalk.cyan(`📂 Sortowanie ${root} → ${expandHome(cfg.organize.target)}\n`));
+    process.stdout.write(chalk.gray(`   Strategia: ${cfg.organize.strategy}, brak tagów: ${cfg.organize.unsorted}\n\n`));
+    const spin = ora('Czytam tagi i buduję plan…').start();
+    let plan;
+    try {
+        plan = await buildOrganizePlan(root, cfg);
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        spin.fail(`Plan failed: ${msg}`);
+        process.exit(1);
+    }
+    spin.succeed(`Plan: ${plan.moves.length} przenosin, ${plan.skips.length} pominięć`);
+    renderPlan(plan, root);
+    if (!opts.apply || opts.dryRun) {
+        process.stdout.write('\n' + chalk.yellow('🔍 Dry-run — żadne pliki nie zostały przeniesione.\n'));
+        process.stdout.write(chalk.gray('   Uruchom z --apply żeby wykonać.\n'));
+        return;
+    }
+    if (plan.moves.length === 0) {
+        process.stdout.write('\n' + chalk.gray('Nic do przenoszenia.\n'));
+        return;
+    }
+    process.stdout.write('\n' + chalk.bold('🚚 Wykonuję przenoszenia…\n'));
+    let ok = 0;
+    let errors = 0;
+    for (const m of plan.moves) {
+        try {
+            await executeMove(m);
+            ok++;
+            if (opts.verbose)
+                process.stdout.write(chalk.gray(`  ✓ ${path.basename(m.from)}\n`));
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            process.stdout.write(chalk.red(`  ✗ ${path.basename(m.from)}: ${msg}\n`));
+            errors++;
+        }
+    }
+    process.stdout.write('\n' + chalk.bold('✨ Done\n'));
+    process.stdout.write(chalk.green(`   ✓ Przeniesione: ${ok}\n`));
+    if (errors)
+        process.stdout.write(chalk.red(`   ✗ Błędy:        ${errors}\n`));
+}

package/dist/commands/sample.js

@@ -0,0 +1,69 @@
+import path from 'node:path';
+import { existsSync } from 'node:fs';
+import chalk from 'chalk';
+import ora from 'ora';
+import { expandHome, loadConfig, configExists } from '../config.js';
+import { preTagFromPath } from '../pretag.js';
+import { mergeTags } from '../tags.js';
+import { inferTagsAndComment } from '../llm/index.js';
+import { pickSampleFiles, ocrSamples } from '../wizard/sample.js';
+import { runWizard } from '../wizard/index.js';
+export async function sampleCommand(folder, opts) {
+    if (!(await configExists(opts.config))) {
+        process.stdout.write(chalk.cyan('🪄 Brak configu — uruchamiam wizard…\n\n'));
+        await runWizard({ configPath: opts.config, folderHint: folder });
+        return;
+    }
+    const { config: cfg } = await loadConfig(opts.config);
+    const root = path.resolve(expandHome(folder ?? cfg.scan.folder));
+    if (!existsSync(root)) {
+        process.stderr.write(chalk.red(`Folder nie istnieje: ${root}\n`));
+        process.exit(1);
+    }
+    const n = opts.count ?? 20;
+    const files = await pickSampleFiles(root, cfg, { count: n, ocrEligibleOnly: true });
+    if (files.length === 0) {
+        process.stdout.write(chalk.yellow('Brak plików do próbkowania.\n'));
+        return;
+    }
+    const spin = ora(`OCR ${files.length} próbek…`).start();
+    const samples = await ocrSamples(files, cfg, (done, total) => {
+        spin.text = `OCR ${done}/${total}`;
+    });
+    spin.succeed('OCR gotowy');
+    let ok = 0;
+    let weak = 0;
+    for (const s of samples) {
+        process.stdout.write(chalk.bold(`\n${s.name}\n`));
+        const preTags = preTagFromPath(s.path, s.ocrText, cfg);
+        let tags;
+        let comment;
+        if (preTags.length >= 4 && !s.ocrText.trim()) {
+            tags = mergeTags(cfg, preTags, [cfg.tags.autoTag]);
+            comment = `Auto z nazwy/ścieżki: ${s.name}.`;
+        }
+        else {
+            try {
+                const res = await inferTagsAndComment({ fileName: s.name, ext: s.ext, preTags, ocrText: s.ocrText }, cfg);
+                tags = res.tags;
+                comment = res.comment;
+            }
+            catch {
+                tags = preTags;
+                comment = `Plik: ${s.name}.`;
+            }
+        }
+        const meaningful = tags.filter(t => t !== cfg.tags.autoTag);
+        const color = meaningful.length >= 2 ? chalk.green : meaningful.length === 1 ? chalk.yellow : chalk.red;
+        if (meaningful.length >= 1)
+            ok++;
+        else
+            weak++;
+        process.stdout.write(color(`  ${tags.join(' ') || '(brak)'}\n`));
+        process.stdout.write(chalk.gray(`  ${comment}\n`));
+    }
+    process.stdout.write('\n');
+    process.stdout.write(chalk.bold('✨ Sample done\n'));
+    process.stdout.write(chalk.green(`   ✓ Otagowane:    ${ok}\n`));
+    process.stdout.write(chalk.red(`   ⚠ Słabe:        ${weak}\n`));
+}

package/dist/commands/tag.js

@@ -0,0 +1,244 @@
+import path from 'node:path';
+import { existsSync } from 'node:fs';
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+import chalk from 'chalk';
+import ora from 'ora';
+import { expandHome, loadConfig, configExists } from '../config.js';
+import { walkFiles } from '../walker.js';
+import { extractOcrText } from '../ocr.js';
+import { preTagFromPath } from '../pretag.js';
+import { mergeTags, TagDiscovery } from '../tags.js';
+import { writeFileMetadata } from '../macos.js';
+import { Masker } from '../mask.js';
+import { inferTagsAndComment } from '../llm/index.js';
+import { findDuplicates } from '../dedup.js';
+import { runWizard } from '../wizard/index.js';
+const execFileAsync = promisify(execFile);
+function applyOverrides(cfg, opts) {
+    const apiKey = opts.apiKey
+        ?? process.env.SORTAI_API_KEY
+        ?? (opts.cloud === 'anthropic' ? process.env.ANTHROPIC_API_KEY : undefined)
+        ?? (opts.cloud === 'openai' ? process.env.OPENAI_API_KEY : undefined)
+        ?? cfg.llm.apiKey;
+    const provider = opts.cloud ?? cfg.llm.provider;
+    const defaultCloudModels = {
+        anthropic: 'claude-sonnet-4-6',
+        openai: 'gpt-4o-mini',
+    };
+    return {
+        ...cfg,
+        scan: {
+            ...cfg.scan,
+            excludeFolders: opts.exclude
+                ? opts.exclude.split(',').map(s => s.trim()).filter(Boolean)
+                : cfg.scan.excludeFolders,
+        },
+        llm: {
+            ...cfg.llm,
+            provider,
+            model: opts.model ?? (opts.cloud ? defaultCloudModels[opts.cloud] ?? cfg.llm.model : cfg.llm.model),
+            ollamaUrl: opts.ollamaUrl ?? cfg.llm.ollamaUrl,
+            apiKey,
+        },
+        mask: {
+            ...cfg.mask,
+            enabled: opts.mask ?? cfg.mask.enabled,
+            lang: opts.lang ?? cfg.mask.lang,
+        },
+        dedup: {
+            ...cfg.dedup,
+            enabled: opts.dedup ?? cfg.dedup.enabled,
+        },
+        tags: {
+            ...cfg.tags,
+            freeForm: opts.free ?? cfg.tags.freeForm,
+        },
+    };
+}
+export async function tagCommand(folder, opts) {
+    if (!(await configExists(opts.config))) {
+        process.stdout.write(chalk.cyan('🪄 Brak configu — uruchamiam interaktywny wizard…\n\n'));
+        const result = await runWizard({ configPath: opts.config, folderHint: folder });
+        if (!result.shouldRunTag)
+            return;
+        folder = folder ?? result.config.scan.folder;
+    }
+    let cfgResult;
+    try {
+        cfgResult = await loadConfig(opts.config);
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        process.stderr.write(chalk.red(`Config error: ${msg}\n`));
+        process.exit(1);
+    }
+    const cfg = applyOverrides(cfgResult.config, opts);
+    if (cfg.llm.provider !== 'ollama' && !cfg.llm.apiKey) {
+        process.stderr.write(chalk.red(`Brak klucza API dla ${cfg.llm.provider}. Podaj --api-key lub ustaw env.\n`));
+        process.exit(1);
+    }
+    const rawFolder = folder ?? cfg.scan.folder;
+    const root = path.resolve(expandHome(rawFolder));
+    if (!existsSync(root)) {
+        process.stderr.write(chalk.red(`Folder nie istnieje: ${root}\n`));
+        process.exit(1);
+    }
+    let masker;
+    if (cfg.mask.enabled && cfg.llm.provider !== 'ollama') {
+        masker = new Masker(cfg);
+        const spin = ora('Starting pseudonym-mcp…').start();
+        try {
+            await masker.connect();
+            spin.succeed('pseudonym-mcp ready');
+        }
+        catch (err) {
+            spin.fail(err instanceof Error ? err.message : String(err));
+            masker = undefined;
+        }
+    }
+    process.stdout.write(chalk.cyan(`🚀 Scanning ${root}\n`));
+    process.stdout.write(`   Provider: ${cfg.llm.provider} (${cfg.llm.model})`);
+    if (cfg.mask.enabled && masker)
+        process.stdout.write(chalk.gray(' [masked]'));
+    if (opts.dryRun)
+        process.stdout.write(chalk.yellow(' [dry-run]'));
+    if (cfg.tags.freeForm)
+        process.stdout.write(chalk.magenta(' [free-form]'));
+    process.stdout.write('\n');
+    if (cfg.scan.excludeFolders.length) {
+        process.stdout.write(chalk.gray(`   Excluded: ${cfg.scan.excludeFolders.join(', ')}\n`));
+    }
+    process.stdout.write('\n');
+    let allFiles = await walkFiles(root, cfg);
+    process.stdout.write(`📁 Files: ${allFiles.length}\n`);
+    if (opts.skipTagged) {
+        const before = allFiles.length;
+        const filtered = [];
+        for (const f of allFiles) {
+            try {
+                const { stdout: md } = await execFileAsync('mdls', ['-name', 'kMDItemUserTags', '-raw', f], { timeout: 3_000 });
+                if (!md.includes(cfg.tags.autoTag))
+                    filtered.push(f);
+            }
+            catch {
+                filtered.push(f);
+            }
+        }
+        allFiles = filtered;
+        process.stdout.write(chalk.gray(`   Skip-tagged: ${before - allFiles.length} pominięte, ${allFiles.length} do przetworzenia\n`));
+    }
+    if (opts.limit && opts.limit > 0 && allFiles.length > opts.limit) {
+        allFiles = allFiles.slice(0, opts.limit);
+        process.stdout.write(chalk.gray(`   Limit: ${opts.limit} plików\n`));
+    }
+    let dedup;
+    if (cfg.dedup.enabled && allFiles.length > 1) {
+        process.stdout.write(chalk.gray(`🔢 Hashing ${allFiles.length} files for dedup…\n`));
+        dedup = await findDuplicates(allFiles, cfg);
+        process.stdout.write(chalk.gray(`   Hashed: ${dedup.hashedFiles}, skipped >${cfg.dedup.maxFileSizeMB}MB: ${dedup.skippedLarge}, ` +
+            `duplicate groups: ${dedup.totalGroups}, files in groups: ${dedup.totalDuplicates}\n`));
+    }
+    process.stdout.write('\n');
+    const stats = { ok: 0, preOnly: 0, skipped: 0, errors: 0, total: allFiles.length };
+    const skipExt = new Set(cfg.scan.skipExtensions);
+    const ocrExt = new Set(cfg.scan.ocrExtensions);
+    const videoExt = new Set(cfg.scan.videoExtensions);
+    const discovery = cfg.tags.freeForm ? new TagDiscovery() : undefined;
+    for (const filePath of allFiles) {
+        const rel = path.relative(root, filePath);
+        const name = path.basename(filePath);
+        const ext = path.extname(filePath).toLowerCase();
+        if (skipExt.has(ext)) {
+            stats.skipped++;
+            continue;
+        }
+        process.stdout.write(chalk.bold(`🔍 ${rel}\n`));
+        let ocrText = '';
+        if (ocrExt.has(ext)) {
+            process.stdout.write('  📖 OCR…');
+            ocrText = await extractOcrText(filePath, cfg);
+            const words = ocrText.split(/\s+/).filter(Boolean).length;
+            process.stdout.write(` ${words} words\n`);
+        }
+        else if (videoExt.has(ext)) {
+            process.stdout.write('  🎬 Video\n');
+        }
+        else {
+            process.stdout.write(`  📄 ${ext}\n`);
+        }
+        const preTagsBase = preTagFromPath(filePath, ocrText, cfg);
+        const dupGroup = dedup?.groupByFile.get(filePath);
+        const preTags = dupGroup ? mergeTags(cfg, preTagsBase, ['#Duplikat']) : preTagsBase;
+        if (dupGroup) {
+            const others = dupGroup.files.filter(f => f !== filePath).map(f => path.basename(f));
+            process.stdout.write(chalk.magenta(`  🧬 Duplicate of: ${others.join(', ')}\n`));
+        }
+        let finalTags;
+        let finalComment;
+        if (preTags.length >= 4 && !ocrText.trim()) {
+            finalTags = mergeTags(cfg, preTags, [cfg.tags.autoTag]);
+            finalComment = `Auto z nazwy/ścieżki: ${name}.`;
+            process.stdout.write(chalk.gray(`  ⚡ Pre-only: ${preTags.join(' ')}\n`));
+            stats.preOnly++;
+        }
+        else {
+            process.stdout.write(chalk.gray(`  🧠 ${cfg.llm.provider}…\n`));
+            const PER_FILE_TIMEOUT_MS = 180_000;
+            let timer;
+            const timeout = new Promise((_, reject) => {
+                timer = setTimeout(() => reject(new Error(`per-file timeout after ${PER_FILE_TIMEOUT_MS}ms`)), PER_FILE_TIMEOUT_MS);
+            });
+            try {
+                const result = await Promise.race([
+                    inferTagsAndComment({ fileName: name, ext, preTags, ocrText }, cfg, masker, discovery),
+                    timeout,
+                ]);
+                finalTags = mergeTags(cfg, result.tags, [cfg.tags.autoTag]);
+                finalComment = result.comment || `Plik: ${name}.`;
+            }
+            catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                process.stdout.write(chalk.yellow(`  ⏱  ${msg} — fallback\n`));
+                finalTags = mergeTags(cfg, preTags, [cfg.tags.autoTag]).slice(0, 6);
+                finalComment = `Plik: ${name}.`;
+            }
+            finally {
+                if (timer)
+                    clearTimeout(timer);
+            }
+        }
+        if (opts.dryRun) {
+            process.stdout.write(chalk.green(`  ✅ ${finalTags.join(' ')}\n`));
+            process.stdout.write(chalk.gray(`  📝 ${finalComment}\n\n`));
+            stats.ok++;
+            continue;
+        }
+        try {
+            await writeFileMetadata(filePath, finalTags, finalComment);
+            process.stdout.write(chalk.green(`  ✅ ${finalTags.join(' ')}\n`));
+            process.stdout.write(chalk.gray(`  📝 ${finalComment}\n\n`));
+            stats.ok++;
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            process.stdout.write(chalk.red(`  ❌ Write failed: ${msg}\n\n`));
+            stats.errors++;
+        }
+    }
+    if (masker)
+        await masker.close();
+    process.stdout.write('═══════════════════════════════════════════════════════\n');
+    process.stdout.write(chalk.bold('✨ Done\n'));
+    process.stdout.write(chalk.green(`   ✅ Success:       ${stats.ok}\n`));
+    process.stdout.write(chalk.gray(`   ⚡ Pre-only:       ${stats.preOnly}\n`));
+    process.stdout.write(chalk.gray(`   ⏭  Skipped:       ${stats.skipped}\n`));
+    process.stdout.write(chalk.red(`   ❌ Errors:        ${stats.errors}\n`));
+    if (discovery && discovery.size > 0) {
+        process.stdout.write('\n' + chalk.magenta(`🆕 Free-form: LLM zaproponował ${discovery.size} nowych tagów:\n`));
+        for (const { tag, count } of discovery.entries().slice(0, 20)) {
+            process.stdout.write(chalk.gray(`   ${tag}  (${count}×)\n`));
+        }
+        process.stdout.write(chalk.gray('\n   Dodaj je do tags.allowed w configu jeśli chcesz je zachować.\n'));
+    }
+}

package/dist/config.js

@@ -3,12 +3,22 @@ import { existsSync } from 'node:fs';
 import path from 'node:path';
 import os from 'node:os';
 import { z } from 'zod';
-import { DEFAULT_CONFIG } from './defaults.js';
+import { DEFAULT_CONFIG, DEFAULT_ORGANIZE } from './defaults.js';
 const PathRuleSchema = z.object({
     pattern: z.string(),
     flags: z.string().optional(),
     tags: z.array(z.string()),
 });
+const OrganizeSchema = z.object({
+    enabled: z.boolean().default(false),
+    target: z.string().default('~/Documents/Sorted'),
+    strategy: z.enum(['flat', 'nested', 'custom']).default('flat'),
+    priority: z.array(z.string()).default([]),
+    folderMap: z.record(z.string(), z.string()).default({}),
+    unsorted: z.enum(['keep', 'move', 'skip']).default('move'),
+    unsortedFolder: z.string().default('_unsorted'),
+    multiTag: z.enum(['primary']).default('primary'),
+}).default(DEFAULT_ORGANIZE);
 const ConfigSchema = z.object({
     scan: z.object({
         folder: z.string(),
@@ -46,7 +56,9 @@ const ConfigSchema = z.object({
         strictEvidence: z.record(z.string(), z.array(z.string())),
         pathRules: z.array(PathRuleSchema),
         autoTag: z.string(),
+        freeForm: z.boolean().default(false),
     }),
+    organize: OrganizeSchema,
     context: z.string(),
 });
 export const DEFAULT_CONFIG_PATH = path.join(process.env.XDG_CONFIG_HOME ?? path.join(os.homedir(), '.config'), 'sortai', 'config.json');
@@ -56,8 +68,14 @@ export function expandHome(p) {
     }
     return p;
 }
+export function resolveConfigPath(customPath) {
+    return customPath ? path.resolve(expandHome(customPath)) : DEFAULT_CONFIG_PATH;
+}
+export async function configExists(customPath) {
+    return existsSync(resolveConfigPath(customPath));
+}
 export async function loadConfig(customPath) {
-    const cfgPath = customPath ? path.resolve(expandHome(customPath)) : DEFAULT_CONFIG_PATH;
+    const cfgPath = resolveConfigPath(customPath);
     if (!existsSync(cfgPath)) {
         await fs.mkdir(path.dirname(cfgPath), { recursive: true });
         await fs.writeFile(cfgPath, JSON.stringify(DEFAULT_CONFIG, null, 2), 'utf8');
@@ -68,3 +86,13 @@ export async function loadConfig(customPath) {
     const config = ConfigSchema.parse(parsed);
     return { config, path: cfgPath, created: false };
 }
+export async function saveConfig(config, customPath) {
+    const cfgPath = resolveConfigPath(customPath);
+    await fs.mkdir(path.dirname(cfgPath), { recursive: true });
+    if (existsSync(cfgPath)) {
+        const backup = `${cfgPath}.bak.${Date.now()}`;
+        await fs.copyFile(cfgPath, backup);
+    }
+    await fs.writeFile(cfgPath, JSON.stringify(config, null, 2), 'utf8');
+    return cfgPath;
+}

package/dist/defaults.js

@@ -74,6 +74,22 @@ export const DEFAULT_CONTEXT = 'EDIT ME in ~/.config/sortai/config.json. 1-2 sen
     'used by the LLM as background context to prefer the right tags. ' +
     'Example: "Self-employed graphic designer in Warsaw. Recurring clients: AcmeCorp, BetaInc. ' +
     'Documents in PL and EN. Active: tax filings 2024, AcmeCorp branding project."';
+export const DEFAULT_ORGANIZE = {
+    enabled: false,
+    target: '~/Documents/Sorted',
+    strategy: 'flat',
+    priority: [
+        '#Faktura', '#FakturaProforma', '#Wyciag', '#Bank', '#KartaKredytowa', '#Kredyt', '#Podatki',
+        '#Umowa', '#Wniosek', '#Reklamacja', '#Skarga', '#Decyzja', '#Oswiadczenie', '#Ugoda',
+        '#Protokol', '#Regulamin', '#Harmonogram', '#Oferta', '#Pismo', '#Korespondencja',
+        '#CV', '#Kariera', '#Nieruchomosc', '#Zdrowie', '#RODO',
+        '#Email', '#Zalacznik', '#Skan', '#Screenshot', '#Foto', '#Grafika', '#Nagranie',
+    ],
+    folderMap: {},
+    unsorted: 'move',
+    unsortedFolder: '_unsorted',
+    multiTag: 'primary',
+};
 export const DEFAULT_CONFIG = {
     scan: {
         folder: '~/Desktop',
@@ -110,7 +126,9 @@ export const DEFAULT_CONFIG = {
         strictEvidence: DEFAULT_STRICT_EVIDENCE,
         pathRules: DEFAULT_PATH_RULES,
         autoTag: '#AI_Sorted',
+        freeForm: false,
     },
+    organize: DEFAULT_ORGANIZE,
     context: DEFAULT_CONTEXT,
 };
 export const BAD_COMMENT_PHRASES = [

package/dist/llm/index.js

@@ -1,6 +1,6 @@
-import { mergeTags, normalizeTag, isStrictTag, strictTagHasEvidence } from '../tags.js';
+import { mergeTags, normalizeTag, isStrictTag, strictTagHasEvidence, TAG_SHAPE } from '../tags.js';
 import { BAD_COMMENT_PHRASES } from '../defaults.js';
-import { buildPrompt, parseJsonSafe } from './prompt.js';
+import { buildPrompt, buildTaxonomyPrompt, parseJsonSafe } from './prompt.js';
 import { callOllama } from './local.js';
 import { callAnthropic, callOpenAi } from './cloud.js';
 async function dispatchProvider(prompt, cfg) {
@@ -14,7 +14,7 @@ async function dispatchProvider(prompt, cfg) {
             return callOllama(prompt, cfg);
     }
 }
-export async function inferTagsAndComment(req, cfg, masker) {
+export async function inferTagsAndComment(req, cfg, masker, discovery) {
     const fallback = {
         tags: mergeTags(cfg, req.preTags).slice(0, 6),
         comment: `Plik: ${req.fileName}.`,
@@ -48,8 +48,9 @@ export async function inferTagsAndComment(req, cfg, masker) {
     const rawTags = Array.isArray(data.tags) ? data.tags : [];
     const evidence = (req.fileName + ' ' + req.ocrText).toLowerCase();
     const cleaned = [];
+    const allowedSet = new Set([...cfg.tags.allowed, cfg.tags.autoTag]);
     for (const t of rawTags) {
-        const n = normalizeTag(t, cfg);
+        const n = normalizeTag(t, cfg, cfg.tags.freeForm);
         if (!n)
             continue;
         if (isStrictTag(n, cfg)) {
@@ -59,6 +60,9 @@ export async function inferTagsAndComment(req, cfg, masker) {
         else {
             cleaned.push(n);
         }
+        if (cfg.tags.freeForm && !allowedSet.has(n)) {
+            discovery?.record(n);
+        }
     }
     applyContextualGuards(cleaned, req, cfg, evidence);
     const strictFound = cleaned.filter(t => isStrictTag(t, cfg));
@@ -85,6 +89,45 @@ export async function inferTagsAndComment(req, cfg, masker) {
         comment: comment.slice(0, 500),
     };
 }
+export async function inferTaxonomy(samples, langs, userContext, cfg, hint) {
+    const prompt = buildTaxonomyPrompt(samples, langs, userContext, hint);
+    // Taksonomia to duży JSON (8-15 kategorii z aliasami, evidence, examples) —
+    // domyślne 300 tokenów ucinają output w połowie. Wymuszamy 2000.
+    const taxCfg = { ...cfg, llm: { ...cfg.llm, numPredict: Math.max(cfg.llm.numPredict, 2000) } };
+    const raw = await dispatchProvider(prompt, taxCfg);
+    const data = parseJsonSafe(raw);
+    const categories = Array.isArray(data.categories) ? data.categories : [];
+    const parsed = [];
+    for (const c of categories) {
+        if (!c || typeof c !== 'object')
+            continue;
+        const obj = c;
+        const name = typeof obj.name === 'string' ? obj.name.trim() : '';
+        if (!name)
+            continue;
+        const normalized = name.startsWith('#') ? name : `#${name}`;
+        if (!TAG_SHAPE.test(normalized))
+            continue;
+        parsed.push({
+            name: normalized,
+            description: typeof obj.description === 'string' ? obj.description : '',
+            aliases: Array.isArray(obj.aliases)
+                ? obj.aliases.filter((x) => typeof x === 'string').map(s => s.startsWith('#') ? s : `#${s}`)
+                : [],
+            strictEvidence: Array.isArray(obj.strict_evidence)
+                ? obj.strict_evidence.filter((x) => typeof x === 'string')
+                : [],
+            isStrict: Boolean(obj.is_strict),
+            examples: Array.isArray(obj.examples)
+                ? obj.examples.filter((x) => typeof x === 'string')
+                : [],
+        });
+    }
+    return {
+        categories: parsed,
+        summary: typeof data.summary === 'string' ? data.summary : '',
+    };
+}
 function isBadComment(c) {
     if (!c)
         return true;

package/dist/llm/ollama-detect.js

@@ -0,0 +1,35 @@
+export async function probeOllama(url, timeoutMs = 2_000) {
+    const base = url.replace(/\/$/, '');
+    const controller = new AbortController();
+    const t = setTimeout(() => controller.abort(), timeoutMs);
+    try {
+        const res = await fetch(`${base}/api/tags`, { signal: controller.signal });
+        if (!res.ok) {
+            return { reachable: false, models: [], error: `HTTP ${res.status}` };
+        }
+        const data = (await res.json());
+        const models = (data.models ?? [])
+            .filter((m) => typeof m.name === 'string' && typeof m.size === 'number' && typeof m.modified_at === 'string')
+            .map(m => ({ name: m.name, size: m.size, modified: m.modified_at }));
+        return { reachable: true, models };
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        return { reachable: false, models: [], error: msg };
+    }
+    finally {
+        clearTimeout(t);
+    }
+}
+export function modelSizeLabel(bytes) {
+    const gb = bytes / 1024 / 1024 / 1024;
+    if (gb >= 1)
+        return `${gb.toFixed(1)} GB`;
+    const mb = bytes / 1024 / 1024;
+    return `${mb.toFixed(0)} MB`;
+}
+export const SUGGESTED_OLLAMA_MODELS = [
+    { name: 'mistral-nemo', note: '12B — dobry baseline, szybkie' },
+    { name: 'qwen2.5:14b', note: '14B — lepsza taksonomia' },
+    { name: 'llama3.1', note: '8B — najszybsze, słabsze taksonomie' },
+];

package/dist/llm/prompt.js

@@ -54,6 +54,37 @@ export function buildPrompt(req, cfg, ocrTextForPrompt) {
         '3. BĄDŹ SCEPTYCZNY. Lepiej dać 1 tag (#Grafika) niż 5 błędnych.',
     ].join('\n');
 }
+export function buildTaxonomyPrompt(samples, langs, userContext, hint) {
+    const samplesBlock = samples
+        .map((s, i) => {
+        const trimmed = s.ocrText.slice(0, 600).trim() || '(brak tekstu OCR – plik graficzny/wideo)';
+        return `--- Plik ${i + 1} ---\nnazwa: ${s.name}\nrozszerzenie: ${s.ext}\nOCR:\n${trimmed}`;
+    })
+        .join('\n\n');
+    const langLabel = langs.length === 0 ? 'nieznany' : langs.join(' + ');
+    return [
+        'Jesteś asystentem budującym taksonomię tagów Findera dla prywatnej kolekcji plików.',
+        'Poniżej znajdziesz próbki plików (nazwa + fragment OCR). Zaproponuj 8-15 ZRÓŻNICOWANYCH kategorii.',
+        '',
+        `Wykryte języki: ${langLabel}`,
+        `Kontekst użytkownika: ${userContext || '(brak)'}`,
+        hint ? `Dodatkowa wskazówka: ${hint}` : '',
+        '',
+        'Dla każdej kategorii podaj:',
+        '- name: nazwa tagu w formacie #PascalCase (jedno słowo, bez spacji, np. #Faktura)',
+        '- description: jedno zdanie po polsku',
+        '- aliases: tablica nazw w innych wykrytych językach (np. ["#Invoice"])',
+        '- strict_evidence: 3-5 słów-dowodów które MUSZĄ pojawić się w OCR/nazwie żeby tag był nałożony (dla kategorii wrażliwych: finansowych, prawnych, zdrowotnych)',
+        '- is_strict: true tylko dla wrażliwych kategorii (Bank, Faktura, RODO, Zdrowie, Podatki, KartaKredytowa, Kredyt)',
+        '- examples: tablica nazw plików z próbki które pasują do tej kategorii',
+        '',
+        'Zwróć WYŁĄCZNIE JSON w formacie:',
+        '{"categories": [{"name":"#X","description":"...","aliases":["#Y"],"strict_evidence":["..."],"is_strict":false,"examples":["..."]}], "summary":"jedno zdanie podsumowania"}',
+        '',
+        'PRÓBKI:',
+        samplesBlock,
+    ].filter(Boolean).join('\n');
+}
 export function parseJsonSafe(raw) {
     const cleaned = raw.trim();
     try {