@woladi/sortai 0.1.1 → 0.2.0

package/dist/wizard/refine.js

@@ -0,0 +1,195 @@
+import chalk from 'chalk';
+import { select, input, confirm, editor } from '@inquirer/prompts';
+import { preTagFromPath } from '../pretag.js';
+import { mergeTags } from '../tags.js';
+import { inferTagsAndComment } from '../llm/index.js';
+import { applyTaxonomyToConfig, generateTaxonomy } from './taxonomy.js';
+function pad(s, w) {
+    return s.length >= w ? s : s + ' '.repeat(w - s.length);
+}
+export function renderTaxonomyTable(tax) {
+    if (tax.categories.length === 0)
+        return chalk.yellow('(brak kategorii)');
+    const lines = [];
+    const nameW = Math.max(6, ...tax.categories.map(c => c.name.length));
+    lines.push(chalk.bold(`${pad('Tag', nameW)}  Strict  Przykłady`));
+    lines.push(chalk.gray('─'.repeat(Math.min(80, nameW + 12 + 50))));
+    for (const c of tax.categories) {
+        const examples = c.examples.slice(0, 3).join(', ') || chalk.gray('(brak)');
+        const strict = c.isStrict ? chalk.yellow('  ✓   ') : '      ';
+        lines.push(`${pad(c.name, nameW)}  ${strict}  ${examples}`);
+    }
+    if (tax.summary) {
+        lines.push('');
+        lines.push(chalk.gray(`Podsumowanie: ${tax.summary}`));
+    }
+    return lines.join('\n');
+}
+async function editCategory(cat) {
+    while (true) {
+        const action = await select({
+            message: `Edytuj ${chalk.cyan(cat.name)} (strict=${cat.isStrict}, aliasy=[${cat.aliases.join(',')}])`,
+            choices: [
+                { name: 'Zmień nazwę', value: 'name' },
+                { name: 'Zmień opis', value: 'desc' },
+                { name: 'Zmień aliasy (CSV)', value: 'aliases' },
+                { name: cat.isStrict ? 'Wyłącz strict' : 'Włącz strict', value: 'strict' },
+                { name: 'Zmień strict_evidence (CSV)', value: 'evidence' },
+                { name: chalk.red('Usuń tag'), value: 'drop' },
+                { name: chalk.green('Gotowe'), value: 'done' },
+            ],
+        });
+        if (action === 'done')
+            return cat;
+        if (action === 'drop')
+            return null;
+        if (action === 'name') {
+            const v = await input({ message: 'Nowa nazwa (#Tag):', default: cat.name });
+            cat.name = v.startsWith('#') ? v : `#${v}`;
+        }
+        else if (action === 'desc') {
+            cat.description = await input({ message: 'Opis:', default: cat.description });
+        }
+        else if (action === 'aliases') {
+            const v = await input({ message: 'Aliasy (oddzielone przecinkiem):', default: cat.aliases.join(',') });
+            cat.aliases = v.split(',').map(s => s.trim()).filter(Boolean).map(a => a.startsWith('#') ? a : `#${a}`);
+        }
+        else if (action === 'strict') {
+            cat.isStrict = !cat.isStrict;
+        }
+        else if (action === 'evidence') {
+            const v = await input({ message: 'Słowa-dowody (oddzielone przecinkiem):', default: cat.strictEvidence.join(',') });
+            cat.strictEvidence = v.split(',').map(s => s.trim()).filter(Boolean);
+        }
+    }
+}
+async function showSamplePreview(taxonomy, samples, baseCfg) {
+    const cfg = applyTaxonomyToConfig(taxonomy, baseCfg);
+    process.stdout.write('\n' + chalk.cyan('🔍 Podgląd tagowania na próbce (bez zapisu):\n\n'));
+    for (const s of samples.slice(0, 10)) {
+        const preTags = preTagFromPath(s.path, s.ocrText, cfg);
+        process.stdout.write(chalk.bold(`  ${s.name}\n`));
+        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 color = tags.length >= 2 ? chalk.green : tags.length === 1 ? chalk.yellow : chalk.red;
+        process.stdout.write(color(`    ${tags.join(' ') || '(brak tagów)'}\n`));
+        process.stdout.write(chalk.gray(`    ${comment}\n`));
+    }
+    process.stdout.write('\n');
+}
+export async function refineTaxonomyLoop(initial, deps) {
+    let taxonomy = { ...initial, categories: [...initial.categories] };
+    while (true) {
+        process.stdout.write('\n' + renderTaxonomyTable(taxonomy) + '\n\n');
+        const action = await select({
+            message: 'Co dalej z taksonomią?',
+            choices: [
+                { name: chalk.green('Akceptuj i zapisz config'), value: 'accept' },
+                { name: 'Edytuj per-tag (rename / strict / drop / evidence)', value: 'edit' },
+                { name: 'Dodaj nowy tag ręcznie', value: 'add' },
+                { name: 'Otwórz w edytorze ($EDITOR)', value: 'editor' },
+                { name: 'Regeneruj LLM-em z dodatkową wskazówką', value: 'regen' },
+                { name: 'Pokaż jak otaguje próbkę z tym configiem', value: 'preview' },
+            ],
+        });
+        if (action === 'accept')
+            return taxonomy;
+        if (action === 'edit') {
+            if (taxonomy.categories.length === 0) {
+                process.stdout.write(chalk.yellow('Brak tagów do edycji.\n'));
+                continue;
+            }
+            const chosen = await select({
+                message: 'Który tag edytować?',
+                choices: taxonomy.categories.map((c, i) => ({ name: `${c.name} (${c.isStrict ? 'strict' : 'safe'})`, value: i })),
+            });
+            const edited = await editCategory({ ...taxonomy.categories[chosen] });
+            const next = [...taxonomy.categories];
+            if (edited === null) {
+                next.splice(chosen, 1);
+            }
+            else {
+                next[chosen] = edited;
+            }
+            taxonomy = { ...taxonomy, categories: next };
+        }
+        if (action === 'add') {
+            const name = await input({ message: 'Nazwa tagu (#Tag):' });
+            if (!name)
+                continue;
+            const normalized = name.startsWith('#') ? name : `#${name}`;
+            const description = await input({ message: 'Opis (opcjonalnie):' });
+            const isStrict = await confirm({ message: 'Tag strict (wymaga słów-dowodów)?', default: false });
+            const evidence = isStrict
+                ? (await input({ message: 'Słowa-dowody (CSV):' })).split(',').map(s => s.trim()).filter(Boolean)
+                : [];
+            const aliasInput = await input({ message: 'Aliasy (CSV, opcjonalnie):' });
+            const aliases = aliasInput.split(',').map(s => s.trim()).filter(Boolean).map(a => a.startsWith('#') ? a : `#${a}`);
+            taxonomy = {
+                ...taxonomy,
+                categories: [
+                    ...taxonomy.categories,
+                    { name: normalized, description, aliases, strictEvidence: evidence, isStrict, examples: [] },
+                ],
+            };
+        }
+        if (action === 'editor') {
+            const draft = JSON.stringify(taxonomy.categories, null, 2);
+            const edited = await editor({
+                message: 'Edytuj kategorie jako JSON. Zapisz i zamknij edytor żeby kontynuować.',
+                default: draft,
+                postfix: '.json',
+            });
+            try {
+                const parsed = JSON.parse(edited);
+                if (Array.isArray(parsed)) {
+                    taxonomy = { ...taxonomy, categories: parsed };
+                }
+                else {
+                    process.stdout.write(chalk.red('Nie tablica — anulowano.\n'));
+                }
+            }
+            catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                process.stdout.write(chalk.red(`Błąd JSON: ${msg} — anulowano.\n`));
+            }
+        }
+        if (action === 'regen') {
+            const hint = await input({
+                message: 'Wskazówka dla LLM (np. "więcej kategorii finansowych", "rozdziel CV i kariera"):',
+            });
+            try {
+                const next = await generateTaxonomy(deps.samples, deps.langs, deps.userContext, deps.baseCfg, hint);
+                taxonomy = next;
+            }
+            catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                process.stdout.write(chalk.red(`Regeneracja nieudana: ${msg}\n`));
+            }
+        }
+        if (action === 'preview') {
+            try {
+                await showSamplePreview(taxonomy, deps.samples, deps.baseCfg);
+            }
+            catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                process.stdout.write(chalk.red(`Podgląd nieudany: ${msg}\n`));
+            }
+        }
+    }
+}

package/dist/wizard/sample.js

@@ -0,0 +1,41 @@
+import path from 'node:path';
+import { walkFiles } from '../walker.js';
+import { extractOcrText } from '../ocr.js';
+function shuffle(arr, seed) {
+    const out = arr.slice();
+    let s = seed ?? Date.now();
+    for (let i = out.length - 1; i > 0; i--) {
+        s = (s * 9301 + 49297) % 233280;
+        const j = Math.floor((s / 233280) * (i + 1));
+        [out[i], out[j]] = [out[j], out[i]];
+    }
+    return out;
+}
+export async function pickSampleFiles(root, cfg, opts) {
+    const all = await walkFiles(root, cfg);
+    const ocrSet = new Set(cfg.scan.ocrExtensions);
+    const filtered = opts.ocrEligibleOnly
+        ? all.filter(f => ocrSet.has(path.extname(f).toLowerCase()))
+        : all;
+    return shuffle(filtered, opts.seed).slice(0, opts.count);
+}
+export async function ocrSamples(files, cfg, onProgress) {
+    const out = [];
+    for (let i = 0; i < files.length; i++) {
+        const f = files[i];
+        const ext = path.extname(f).toLowerCase();
+        onProgress?.(i, files.length, f);
+        let text = '';
+        if (cfg.scan.ocrExtensions.includes(ext)) {
+            text = await extractOcrText(f, cfg);
+        }
+        out.push({
+            path: f,
+            name: path.basename(f),
+            ext,
+            ocrText: text,
+        });
+    }
+    onProgress?.(files.length, files.length, '');
+    return out;
+}

package/dist/wizard/taxonomy.js

@@ -0,0 +1,57 @@
+import { inferTaxonomy } from '../llm/index.js';
+export async function generateTaxonomy(samples, langs, userContext, cfg, hint) {
+    return inferTaxonomy(samples, langs, userContext, cfg, hint);
+}
+export function applyTaxonomyToConfig(taxonomy, cfg) {
+    const allowed = new Set();
+    const strict = [];
+    const aliases = {};
+    const strictEvidence = {};
+    for (const cat of taxonomy.categories) {
+        allowed.add(cat.name);
+        for (const a of cat.aliases) {
+            if (a !== cat.name)
+                aliases[a] = cat.name;
+        }
+        if (cat.isStrict) {
+            strict.push(cat.name);
+            if (cat.strictEvidence.length > 0) {
+                strictEvidence[cat.name] = cat.strictEvidence;
+            }
+        }
+    }
+    allowed.add(cfg.tags.autoTag);
+    allowed.add('#Duplikat');
+    allowed.add('#PrawdopodobnaKopia');
+    allowed.add('#Skan');
+    allowed.add('#Screenshot');
+    allowed.add('#Foto');
+    allowed.add('#Grafika');
+    allowed.add('#Email');
+    allowed.add('#Nagranie');
+    return {
+        ...cfg,
+        tags: {
+            ...cfg.tags,
+            allowed: [...allowed],
+            strict,
+            aliases: { ...cfg.tags.aliases, ...aliases },
+            strictEvidence: { ...cfg.tags.strictEvidence, ...strictEvidence },
+        },
+    };
+}
+export function taxonomyFromConfig(cfg) {
+    const cats = cfg.tags.allowed
+        .filter(t => t !== cfg.tags.autoTag)
+        .map(name => ({
+        name,
+        description: '',
+        aliases: Object.entries(cfg.tags.aliases)
+            .filter(([, target]) => target === name)
+            .map(([alias]) => alias),
+        strictEvidence: cfg.tags.strictEvidence[name] ?? [],
+        isStrict: cfg.tags.strict.includes(name),
+        examples: [],
+    }));
+    return { categories: cats, summary: '' };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@woladi/sortai",
-  "version": "0.1.1",
+  "version": "0.2.0",
   "description": "Automatically tag and describe your files using Apple Vision OCR + local Ollama or cloud LLM — writes native Finder tags and comments searchable in Spotlight",
   "type": "module",
   "main": "./dist/cli.js",
@@ -16,6 +16,9 @@
     "build": "tsc",
     "start": "node dist/cli.js",
     "typecheck": "tsc --noEmit",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "test:e2e": "expect tests/e2e/wizard.expect",
     "prepublishOnly": "npm run build"
   },
   "keywords": [
@@ -41,6 +44,7 @@
   },
   "dependencies": {
     "@anthropic-ai/sdk": "^0.30.1",
+    "@inquirer/prompts": "^8.4.3",
     "@modelcontextprotocol/sdk": "^1.0.4",
     "chalk": "^5.3.0",
     "commander": "^12.1.0",
@@ -49,8 +53,10 @@
     "zod": "^3.23.8"
   },
   "devDependencies": {
+    "@inquirer/testing": "^3.3.6",
     "@types/node": "^20.19.39",
-    "typescript": "^5.4.5"
+    "typescript": "^5.4.5",
+    "vitest": "^4.1.6"
   },
   "engines": {
     "node": ">=20.0.0"