@woladi/sortai 0.1.1 → 0.2.0

package/dist/mask.js

@@ -51,9 +51,15 @@ export class Masker {
             name: 'unmask_text',
             arguments: { text, session_id: sessionId },
         });
-        const parsed = extractJson(result);
-        return typeof parsed.unmasked_text === 'string' ? parsed.unmasked_text :
-            typeof parsed.text === 'string' ? parsed.text : text;
+        const raw = extractRawText(result);
+        const parsed = tryParseJsonObject(raw);
+        if (parsed) {
+            if (typeof parsed.unmasked_text === 'string')
+                return parsed.unmasked_text;
+            if (typeof parsed.text === 'string')
+                return parsed.text;
+        }
+        return raw ?? text;
     }
     async close() {
         if (this.client) {
@@ -63,21 +69,30 @@ export class Masker {
         this.transport = null;
     }
 }
-function extractJson(result) {
+function extractRawText(result) {
     if (!result || typeof result !== 'object')
-        return {};
+        return null;
     const r = result;
-    if (r.structuredContent && typeof r.structuredContent === 'object') {
-        return r.structuredContent;
-    }
     const textBlock = r.content?.find(b => b.type === 'text' && typeof b.text === 'string');
-    if (!textBlock?.text)
-        return {};
+    return textBlock?.text ?? null;
+}
+function tryParseJsonObject(text) {
+    if (!text)
+        return null;
     try {
-        const parsed = JSON.parse(textBlock.text);
-        return parsed && typeof parsed === 'object' ? parsed : {};
+        const parsed = JSON.parse(text);
+        return parsed && typeof parsed === 'object' ? parsed : null;
     }
     catch {
+        return null;
+    }
+}
+function extractJson(result) {
+    if (!result || typeof result !== 'object')
         return {};
+    const r = result;
+    if (r.structuredContent && typeof r.structuredContent === 'object') {
+        return r.structuredContent;
     }
+    return tryParseJsonObject(extractRawText(result)) ?? {};
 }

package/dist/organize/move.js

@@ -0,0 +1,20 @@
+import { promises as fs } from 'node:fs';
+import path from 'node:path';
+import { execFile } from 'node:child_process';
+export async function executeMove(op) {
+    await fs.mkdir(path.dirname(op.to), { recursive: true });
+    try {
+        await fs.rename(op.from, op.to);
+    }
+    catch (err) {
+        const code = err.code;
+        if (code === 'EXDEV') {
+            await fs.copyFile(op.from, op.to);
+            await fs.unlink(op.from);
+        }
+        else {
+            throw err;
+        }
+    }
+    execFile('mdimport', [op.to], { timeout: 5_000 }, () => { });
+}

package/dist/organize/plan.js

@@ -0,0 +1,84 @@
+import path from 'node:path';
+import { existsSync } from 'node:fs';
+import { walkFiles } from '../walker.js';
+import { isMetaTag } from '../tags.js';
+import { expandHome } from '../config.js';
+import { readMacosTags } from './read-tags.js';
+function dedupName(desired, taken) {
+    const key = desired.toLowerCase();
+    if (!taken.has(key) && !existsSync(desired)) {
+        taken.add(key);
+        return desired;
+    }
+    const dir = path.dirname(desired);
+    const ext = path.extname(desired);
+    const base = path.basename(desired, ext);
+    for (let n = 2; n < 10_000; n++) {
+        const cand = path.join(dir, `${base}_${n}${ext}`);
+        const ck = cand.toLowerCase();
+        if (!taken.has(ck) && !existsSync(cand)) {
+            taken.add(ck);
+            return cand;
+        }
+    }
+    taken.add(key);
+    return desired;
+}
+export function pickPrimaryTag(tags, cfg) {
+    const filtered = tags.filter(t => !isMetaTag(t, cfg));
+    if (filtered.length === 0)
+        return null;
+    for (const p of cfg.organize.priority) {
+        if (filtered.includes(p))
+            return p;
+    }
+    return filtered[0];
+}
+export function folderForTag(tag, cfg) {
+    if (cfg.organize.folderMap[tag])
+        return cfg.organize.folderMap[tag];
+    return tag.replace(/^#/, '');
+}
+export async function buildOrganizePlan(root, cfg) {
+    const files = await walkFiles(root, cfg);
+    const moves = [];
+    const skips = [];
+    const taken = new Set();
+    let conflicts = 0;
+    const target = path.resolve(expandHome(cfg.organize.target));
+    for (const file of files) {
+        const tags = await readMacosTags(file);
+        const primary = pickPrimaryTag(tags, cfg);
+        if (!primary) {
+            if (cfg.organize.unsorted === 'skip') {
+                skips.push({ path: file, reason: 'brak tagów (skip)' });
+                continue;
+            }
+            if (cfg.organize.unsorted === 'keep') {
+                skips.push({ path: file, reason: 'brak tagów (zostawiam w miejscu)' });
+                continue;
+            }
+            const desired = path.join(target, cfg.organize.unsortedFolder, path.basename(file));
+            if (path.resolve(desired) === path.resolve(file)) {
+                skips.push({ path: file, reason: 'już w docelowym miejscu' });
+                continue;
+            }
+            const final = dedupName(desired, taken);
+            if (final !== desired)
+                conflicts++;
+            moves.push({ from: file, to: final, primaryTag: '', allTags: tags });
+            continue;
+        }
+        const folder = folderForTag(primary, cfg);
+        const desired = path.join(target, folder, path.basename(file));
+        if (path.resolve(desired) === path.resolve(file)) {
+            skips.push({ path: file, reason: 'już w docelowym miejscu' });
+            continue;
+        }
+        const final = dedupName(desired, taken);
+        if (final !== desired)
+            conflicts++;
+        moves.push({ from: file, to: final, primaryTag: primary, allTags: tags });
+    }
+    return { moves, skips, conflicts };
+}

package/dist/organize/read-tags.js

@@ -0,0 +1,18 @@
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+const execFileAsync = promisify(execFile);
+export async function readMacosTags(filePath) {
+    try {
+        const { stdout } = await execFileAsync('mdls', ['-name', 'kMDItemUserTags', '-raw', filePath], { timeout: 3_000 });
+        const trimmed = stdout.trim();
+        if (!trimmed || trimmed === '(null)')
+            return [];
+        const matches = [...trimmed.matchAll(/"((?:[^"\\]|\\.)*?)"/g)];
+        return matches
+            .map(m => m[1].split('\n')[0])
+            .filter(t => t.startsWith('#'));
+    }
+    catch {
+        return [];
+    }
+}

package/dist/tags.js

@@ -1,4 +1,5 @@
-export function normalizeTag(raw, cfg) {
+export const TAG_SHAPE = /^#[\p{L}\p{N}_-]+$/u;
+export function normalizeTag(raw, cfg, freeForm = false) {
     if (typeof raw !== 'string')
         return null;
     let tag = raw.trim();
@@ -8,7 +9,14 @@ export function normalizeTag(raw, cfg) {
         tag = '#' + tag;
     tag = cfg.tags.aliases[tag] ?? tag;
     const allowed = new Set([...cfg.tags.allowed, cfg.tags.autoTag]);
-    return allowed.has(tag) ? tag : null;
+    if (allowed.has(tag))
+        return tag;
+    if (freeForm || cfg.tags.freeForm) {
+        if (TAG_SHAPE.test(tag))
+            return tag;
+        return null;
+    }
+    return null;
 }
 export function mergeTags(cfg, ...lists) {
     const seen = [];
@@ -16,7 +24,7 @@ export function mergeTags(cfg, ...lists) {
         if (!list)
             continue;
         for (const raw of list) {
-            const normalized = normalizeTag(raw, cfg);
+            const normalized = normalizeTag(raw, cfg, cfg.tags.freeForm);
             if (normalized && !seen.includes(normalized)) {
                 seen.push(normalized);
             }
@@ -34,3 +42,24 @@ export function strictTagHasEvidence(tag, evidence, cfg) {
     const haystack = evidence.toLowerCase();
     return keywords.some(kw => haystack.includes(kw.toLowerCase()));
 }
+export function isMetaTag(tag, cfg) {
+    if (tag === cfg.tags.autoTag)
+        return true;
+    if (tag === '#Duplikat' || tag === '#PrawdopodobnaKopia')
+        return true;
+    return false;
+}
+export class TagDiscovery {
+    counts = new Map();
+    record(tag) {
+        this.counts.set(tag, (this.counts.get(tag) ?? 0) + 1);
+    }
+    entries() {
+        return [...this.counts.entries()]
+            .map(([tag, count]) => ({ tag, count }))
+            .sort((a, b) => b.count - a.count);
+    }
+    get size() {
+        return this.counts.size;
+    }
+}

package/dist/wizard/index.js

@@ -0,0 +1,359 @@
+import path from 'node:path';
+import { existsSync } from 'node:fs';
+import chalk from 'chalk';
+import ora from 'ora';
+import { select, input, confirm, password } from '@inquirer/prompts';
+import { DEFAULT_CONFIG, DEFAULT_ORGANIZE } from '../defaults.js';
+import { expandHome, saveConfig, resolveConfigPath } from '../config.js';
+import { probeOllama, modelSizeLabel, SUGGESTED_OLLAMA_MODELS } from '../llm/ollama-detect.js';
+import { pickSampleFiles, ocrSamples } from './sample.js';
+import { detectLanguages, languageList } from './languages.js';
+import { generateTaxonomy, applyTaxonomyToConfig } from './taxonomy.js';
+import { refineTaxonomyLoop, renderTaxonomyTable } from './refine.js';
+const CLOUD_MODELS = {
+    anthropic: [
+        { name: 'claude-opus-4-7', label: 'Claude Opus 4.7 — najmocniejszy' },
+        { name: 'claude-sonnet-4-6', label: 'Claude Sonnet 4.6 — szybki + mocny (rekomendowany)' },
+        { name: 'claude-haiku-4-5-20251001', label: 'Claude Haiku 4.5 — najszybszy' },
+    ],
+    openai: [
+        { name: 'gpt-4o', label: 'GPT-4o' },
+        { name: 'gpt-4o-mini', label: 'GPT-4o mini — szybki, tani' },
+    ],
+};
+async function askMode() {
+    return select({
+        message: 'Co chcesz robić z plikami?',
+        choices: [
+            { name: 'Tagowanie (Finder tagi + komentarze)', value: 'tag', description: 'Zapisuje tagi i komentarze do xattr plików, indeksuje Spotlight.' },
+            { name: 'Sortowanie do folderów (na bazie istniejących tagów)', value: 'organize', description: 'Przenosi pliki do folderów zgodnie z tagami które już mają.' },
+            { name: 'Tagowanie + sortowanie', value: 'tag+organize', description: 'Najpierw nakłada tagi, potem przenosi do folderów.' },
+            { name: 'Tylko discovery (próbka, bez modyfikacji)', value: 'discovery', description: 'Pokaż jak LLM widzi Twoją kolekcję, bez zapisywania niczego.' },
+        ],
+    });
+}
+async function askScan(defaultFolder) {
+    const folder = await input({ message: 'Folder do skanowania (rekurencyjnie):', default: defaultFolder });
+    const excludeCsv = await input({
+        message: 'Wyklucz podkatalogi (CSV):',
+        default: DEFAULT_CONFIG.scan.excludeFolders.join(','),
+    });
+    return {
+        folder,
+        excludeFolders: excludeCsv.split(',').map(s => s.trim()).filter(Boolean),
+        skipExtensions: DEFAULT_CONFIG.scan.skipExtensions,
+        ocrExtensions: DEFAULT_CONFIG.scan.ocrExtensions,
+        videoExtensions: DEFAULT_CONFIG.scan.videoExtensions,
+    };
+}
+async function askProvider() {
+    return select({
+        message: 'Gdzie ma działać LLM?',
+        choices: [
+            { name: 'Lokalnie (Ollama) — 100% offline, wolniejsze', value: 'ollama' },
+            { name: 'Anthropic Claude — szybkie, wysyła OCR do API', value: 'anthropic' },
+            { name: 'OpenAI — szybkie, wysyła OCR do API', value: 'openai' },
+        ],
+    });
+}
+async function askOllamaModel() {
+    const ollamaUrl = await input({
+        message: 'Adres Ollama:',
+        default: DEFAULT_CONFIG.llm.ollamaUrl,
+    });
+    const spin = ora('Sprawdzam Ollamę…').start();
+    const probe = await probeOllama(ollamaUrl);
+    if (!probe.reachable) {
+        spin.warn(`Ollama nieosiągalna: ${probe.error ?? 'brak odpowiedzi'}`);
+        const proceed = await confirm({
+            message: 'Kontynuować mimo wszystko? (możesz uruchomić `ollama serve` później)',
+            default: true,
+        });
+        if (!proceed)
+            throw new Error('Anulowano przez użytkownika');
+        const model = await input({
+            message: 'Model Ollamy (np. mistral-nemo):',
+            default: DEFAULT_CONFIG.llm.model,
+        });
+        return { model, ollamaUrl };
+    }
+    spin.succeed(`Ollama OK — znaleziono ${probe.models.length} modeli`);
+    if (probe.models.length === 0) {
+        process.stdout.write(chalk.yellow('\n⚠️  Brak zainstalowanych modeli. Sugerowane:\n'));
+        for (const s of SUGGESTED_OLLAMA_MODELS) {
+            process.stdout.write(`   ${chalk.cyan(`ollama pull ${s.name}`)}  — ${s.note}\n`);
+        }
+        process.stdout.write('\n');
+        const model = await input({
+            message: 'Model którego użyjesz (wpisz nazwę):',
+            default: 'mistral-nemo',
+        });
+        return { model, ollamaUrl };
+    }
+    const isEmbedding = (name) => /embed/i.test(name);
+    const usable = probe.models.filter(m => !isEmbedding(m.name));
+    const embedders = probe.models.filter(m => isEmbedding(m.name));
+    const choices = [
+        ...usable.map(m => ({
+            name: `${m.name}  ${chalk.gray('(' + modelSizeLabel(m.size) + ')')}`,
+            value: m.name,
+        })),
+        ...embedders.map(m => ({
+            name: `${m.name}  ${chalk.gray('(' + modelSizeLabel(m.size) + ') — embedding, nie do tagowania')}`,
+            value: m.name,
+        })),
+        { name: chalk.gray('— wpisz inny —'), value: '__custom__' },
+    ];
+    const picked = await select({
+        message: 'Wybierz model Ollamy:',
+        choices,
+    });
+    const model = picked === '__custom__'
+        ? await input({ message: 'Nazwa modelu:', default: 'mistral-nemo' })
+        : picked;
+    const smallNames = ['llama3.1', 'llama3', 'phi', 'gemma:2b', 'mistral', 'tinyllama'];
+    if (smallNames.some(s => model.toLowerCase().includes(s))) {
+        process.stdout.write(chalk.yellow('\n⚠️  Mały model — wygenerowana taksonomia może być szorstka.\n' +
+            '   Możesz później użyć trybu cloud do init, a Ollamy do tagowania.\n\n'));
+    }
+    return { model, ollamaUrl };
+}
+async function askCloud(provider, existingKey) {
+    const envKey = provider === 'anthropic' ? process.env.ANTHROPIC_API_KEY : process.env.OPENAI_API_KEY;
+    let apiKey = existingKey ?? envKey ?? '';
+    if (!apiKey) {
+        apiKey = await password({
+            message: `Klucz API ${provider} (zostanie zapisany w configu):`,
+            mask: '*',
+        });
+    }
+    else {
+        process.stdout.write(chalk.gray(`   Klucz API wykryty z env: ${apiKey.slice(0, 8)}…\n`));
+    }
+    const model = await select({
+        message: `Model ${provider}:`,
+        choices: CLOUD_MODELS[provider].map(m => ({ name: m.label, value: m.name })),
+    });
+    return { model, apiKey };
+}
+async function askMask() {
+    const enabled = await confirm({
+        message: 'Włączyć pseudonimizację PII (pseudonym-mcp) przed wysyłką do cloud?',
+        default: false,
+    });
+    if (!enabled)
+        return { enabled: false, lang: 'pl' };
+    const lang = await select({
+        message: 'Język danych (dla regułek pseudonimizacji):',
+        choices: [
+            { name: 'Polski', value: 'pl' },
+            { name: 'English', value: 'en' },
+        ],
+    });
+    return { enabled: true, lang };
+}
+async function askContext() {
+    process.stdout.write(chalk.gray('Krótki opis siebie/branży/aktualnych spraw. LLM użyje tego jako tła przy tagowaniu.\n' +
+        'Przykład: "Freelancer-projektant w Warszawie. Klienci: AcmeCorp. Aktualne: rozliczenia 2024."\n'));
+    return input({
+        message: 'Kontekst (możesz pominąć, edytujesz później):',
+        default: '',
+    });
+}
+async function askFreeForm() {
+    return confirm({
+        message: 'Pozwolić LLM-owi proponować NOWE tagi (free-form)? Pokażę je w podsumowaniu.',
+        default: false,
+    });
+}
+async function askOrganize(allowed) {
+    const target = await input({
+        message: 'Folder docelowy dla sortowania:',
+        default: DEFAULT_ORGANIZE.target,
+    });
+    const strategy = await select({
+        message: 'Strategia układu folderów:',
+        choices: [
+            { name: 'Flat — jeden folder per tag (Faktura/, Bank/)', value: 'flat' },
+            { name: 'Nested — priorytet wygrywa, plik trafia tylko do jednego folderu', value: 'nested' },
+            { name: 'Custom — niestandardowe mapowanie tag→folder', value: 'custom' },
+        ],
+    });
+    const unsorted = await select({
+        message: 'Co z plikami bez tagów?',
+        choices: [
+            { name: 'Przenieś do _unsorted/', value: 'move' },
+            { name: 'Zostaw w miejscu', value: 'keep' },
+            { name: 'Pomiń całkowicie', value: 'skip' },
+        ],
+    });
+    return {
+        enabled: true,
+        target,
+        strategy,
+        priority: allowed,
+        folderMap: {},
+        unsorted,
+        unsortedFolder: '_unsorted',
+        multiTag: 'primary',
+    };
+}
+async function runDiscoverySampling(scan, count) {
+    const cfgBase = { ...DEFAULT_CONFIG, scan };
+    const root = path.resolve(expandHome(scan.folder));
+    if (!existsSync(root))
+        throw new Error(`Folder nie istnieje: ${root}`);
+    const files = await pickSampleFiles(root, cfgBase, { count, ocrEligibleOnly: true });
+    if (files.length === 0) {
+        throw new Error(`Brak plików do OCR w ${root}. Sprawdź rozszerzenia / wykluczenia.`);
+    }
+    const spin = ora(`OCR próbki (${files.length} plików)…`).start();
+    const samples = await ocrSamples(files, cfgBase, (done, total, file) => {
+        spin.text = `OCR ${done}/${total}: ${file ? path.basename(file) : ''}`;
+    });
+    spin.succeed(`OCR gotowy: ${samples.length} plików`);
+    return { files, samples, cfgBase };
+}
+export async function runWizard(opts) {
+    process.stdout.write(chalk.bold.cyan('\n✨ sortai — interaktywny wizard\n\n'));
+    const mode = await askMode();
+    process.stdout.write('\n' + chalk.bold('📁 Folder\n'));
+    const scan = await askScan(opts.folderHint ?? DEFAULT_CONFIG.scan.folder);
+    let provider = DEFAULT_CONFIG.llm.provider;
+    let model = DEFAULT_CONFIG.llm.model;
+    let ollamaUrl = DEFAULT_CONFIG.llm.ollamaUrl;
+    let apiKey;
+    let mask = { ...DEFAULT_CONFIG.mask };
+    const needsLlm = mode === 'tag' || mode === 'tag+organize' || mode === 'discovery';
+    if (needsLlm) {
+        process.stdout.write('\n' + chalk.bold('🧠 LLM\n'));
+        provider = await askProvider();
+        if (provider === 'ollama') {
+            const o = await askOllamaModel();
+            model = o.model;
+            ollamaUrl = o.ollamaUrl;
+        }
+        else {
+            const c = await askCloud(provider, opts.apiKey);
+            model = c.model;
+            apiKey = c.apiKey || undefined;
+            mask = await askMask();
+        }
+    }
+    process.stdout.write('\n' + chalk.bold('💬 Kontekst\n'));
+    const context = needsLlm ? await askContext() : DEFAULT_CONFIG.context;
+    const freeForm = needsLlm ? await askFreeForm() : false;
+    let cfg = {
+        ...DEFAULT_CONFIG,
+        scan,
+        llm: {
+            provider,
+            model,
+            temperature: DEFAULT_CONFIG.llm.temperature,
+            numPredict: DEFAULT_CONFIG.llm.numPredict,
+            ollamaUrl,
+            apiKey,
+        },
+        mask,
+        tags: { ...DEFAULT_CONFIG.tags, freeForm },
+        organize: { ...DEFAULT_ORGANIZE },
+        context: context || DEFAULT_CONFIG.context,
+    };
+    const wantsTaxonomy = needsLlm && (mode === 'tag' || mode === 'tag+organize' || mode === 'discovery');
+    if (wantsTaxonomy) {
+        process.stdout.write('\n' + chalk.bold('🔬 Próbkowanie\n'));
+        const sampleCount = Number(await input({
+            message: 'Ile plików zsamplować do generacji taksonomii?',
+            default: '30',
+            validate: v => /^\d+$/.test(v) && Number(v) > 0 ? true : 'Liczba dodatnia',
+        }));
+        let sampling;
+        try {
+            sampling = await runDiscoverySampling(scan, sampleCount);
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            process.stdout.write(chalk.red(`\nProblem z próbkowaniem: ${msg}\n`));
+            process.stdout.write(chalk.yellow('Zapisuję config bez taksonomii — uzupełnisz po dograniu plików.\n\n'));
+            return finalize(cfg, opts, mode);
+        }
+        const { samples } = sampling;
+        const lang = detectLanguages(samples.map(s => s.ocrText));
+        const langs = languageList(lang);
+        process.stdout.write(chalk.gray(`   Wykryty język: ${langs.join(' + ')} ` +
+            `(PL ${(lang.scores.pl * 100).toFixed(0)}% / EN ${(lang.scores.en * 100).toFixed(0)}%)\n`));
+        process.stdout.write('\n' + chalk.bold('🪄 Generacja taksonomii (LLM)\n'));
+        const taxSpin = ora(`Pytam ${provider}:${model} o taksonomię…`).start();
+        let taxonomy;
+        try {
+            taxonomy = await generateTaxonomy(samples, langs, cfg.context, cfg);
+            taxSpin.succeed(`Wygenerowano ${taxonomy.categories.length} kategorii`);
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            taxSpin.fail(`Nieudane: ${msg}`);
+            process.stdout.write(chalk.yellow('Zapisuję config z domyślną taksonomią.\n\n'));
+            return finalize(cfg, opts, mode);
+        }
+        if (provider === 'ollama') {
+            process.stdout.write(chalk.yellow('\n⚠️  To DRAFT z lokalnego modelu — przejrzyj kategorie i popraw co trzeba.\n'));
+        }
+        if (mode !== 'discovery') {
+            taxonomy = await refineTaxonomyLoop(taxonomy, {
+                samples,
+                langs,
+                userContext: cfg.context,
+                baseCfg: cfg,
+            });
+            cfg = applyTaxonomyToConfig(taxonomy, cfg);
+        }
+        else {
+            process.stdout.write('\n' + chalk.bold('🔎 Discovery — proponowana taksonomia:\n\n'));
+            process.stdout.write(renderTaxonomyTable(taxonomy) + '\n');
+            const save = await confirm({ message: 'Zapisać tę taksonomię do configu?', default: false });
+            if (save)
+                cfg = applyTaxonomyToConfig(taxonomy, cfg);
+        }
+    }
+    if (mode === 'organize' || mode === 'tag+organize') {
+        process.stdout.write('\n' + chalk.bold('📂 Sortowanie\n'));
+        cfg.organize = await askOrganize(cfg.tags.allowed);
+    }
+    return finalize(cfg, opts, mode);
+}
+async function finalize(cfg, opts, mode) {
+    process.stdout.write('\n' + chalk.bold('💾 Zapis\n'));
+    const cfgPath = resolveConfigPath(opts.configPath);
+    const exists = existsSync(cfgPath);
+    if (exists) {
+        process.stdout.write(chalk.gray(`   Istniejący config zostanie zarchiwizowany: ${cfgPath}.bak.*\n`));
+    }
+    const savedPath = await saveConfig(cfg, opts.configPath);
+    process.stdout.write(chalk.green(`   ✓ Zapisano ${savedPath}\n`));
+    let shouldRunTag = false;
+    let shouldRunOrganize = false;
+    if (mode !== 'discovery') {
+        const runNow = await confirm({
+            message: mode === 'tag+organize'
+                ? 'Uruchomić teraz tagowanie + sortowanie?'
+                : mode === 'organize'
+                    ? 'Uruchomić teraz sortowanie?'
+                    : 'Uruchomić teraz tagowanie?',
+            default: false,
+        });
+        if (runNow) {
+            shouldRunTag = mode === 'tag' || mode === 'tag+organize';
+            shouldRunOrganize = mode === 'organize' || mode === 'tag+organize';
+        }
+        else {
+            process.stdout.write(chalk.gray('\nMożesz uruchomić później:\n'));
+            if (mode === 'tag' || mode === 'tag+organize') {
+                process.stdout.write(`   ${chalk.cyan(`sortai tag ${cfg.scan.folder}`)}\n`);
+            }
+            if (mode === 'organize' || mode === 'tag+organize') {
+                process.stdout.write(`   ${chalk.cyan(`sortai organize ${cfg.scan.folder} --apply`)}\n`);
+            }
+        }
+    }
+    return { config: cfg, configPath: savedPath, mode, shouldRunTag, shouldRunOrganize };
+}

package/dist/wizard/languages.js

@@ -0,0 +1,34 @@
+const STOPWORDS = {
+    pl: ['i ', ' w ', ' na ', ' z ', ' do ', ' się ', ' nie ', ' jest ', ' są ', ' oraz ', ' lub ', ' za ', ' od ', ' dla ', ' co ', ' to ', ' już ', ' tym ', ' przez ', ' przy ', ' aby '],
+    en: [' the ', ' and ', ' of ', ' to ', ' for ', ' in ', ' on ', ' is ', ' are ', ' with ', ' by ', ' as ', ' at ', ' from ', ' this ', ' that ', ' be ', ' or ', ' has ', ' have '],
+};
+export function detectLanguages(texts) {
+    const scores = { pl: 0, en: 0 };
+    for (const txt of texts) {
+        if (!txt)
+            continue;
+        const lower = ' ' + txt.toLowerCase().replace(/\s+/g, ' ') + ' ';
+        for (const lang of Object.keys(STOPWORDS)) {
+            for (const sw of STOPWORDS[lang]) {
+                let idx = 0;
+                while ((idx = lower.indexOf(sw, idx)) !== -1) {
+                    scores[lang]++;
+                    idx += sw.length;
+                }
+            }
+        }
+    }
+    const total = scores.pl + scores.en;
+    const ratios = {
+        pl: total > 0 ? scores.pl / total : 0,
+        en: total > 0 ? scores.en / total : 0,
+    };
+    const dominant = ratios.pl >= ratios.en ? 'pl' : 'en';
+    const bilingual = total > 0 && Math.min(ratios.pl, ratios.en) >= 0.2;
+    return { dominant, scores: ratios, bilingual };
+}
+export function languageList(result) {
+    if (result.bilingual)
+        return ['pl', 'en'];
+    return [result.dominant];
+}