@woladi/sortai 0.1.0

package/dist/defaults.js

@@ -0,0 +1,123 @@
+export const DEFAULT_ALLOWED_TAGS = [
+    '#Bank', '#Faktura', '#FakturaProforma', '#Wyciag', '#Kredyt', '#KartaKredytowa', '#Podatki',
+    '#CV', '#Kariera', '#Umowa', '#Oferta', '#Korespondencja',
+    '#Pismo', '#Wniosek', '#Reklamacja', '#Skarga', '#Decyzja', '#Oswiadczenie', '#Ugoda',
+    '#Protokol', '#Regulamin', '#Harmonogram',
+    '#Nieruchomosc', '#Zdrowie', '#RODO',
+    '#Wyslane', '#Odebrane', '#Draft', '#Zalacznik',
+    '#Duplikat', '#PrawdopodobnaKopia',
+    '#Skan', '#Screenshot', '#Nagranie', '#Email', '#Foto', '#Grafika',
+    '#AI_Sorted',
+];
+export const DEFAULT_STRICT_TAGS = [
+    '#Bank', '#Faktura', '#KartaKredytowa', '#Kredyt', '#Podatki',
+    '#RODO', '#Zdrowie',
+    '#PrawdopodobnaKopia',
+];
+export const DEFAULT_TAG_ALIASES = {
+    '#Karta': '#KartaKredytowa',
+    '#Invoice': '#Faktura',
+    '#Mortgage': '#Kredyt',
+    '#Loan': '#Kredyt',
+    '#Tax': '#Podatki',
+    '#GDPR': '#RODO',
+    '#Health': '#Zdrowie',
+    '#Screen': '#Screenshot',
+    '#Photo': '#Foto',
+    '#Graphic': '#Grafika',
+    '#Video': '#Nagranie',
+    '#Resume': '#CV',
+    '#Contract': '#Umowa',
+};
+export const DEFAULT_STRICT_EVIDENCE = {
+    '#Bank': ['bank', 'iban', 'rachunek bankowy', 'numer konta', 'account number'],
+    '#Faktura': ['faktura', 'invoice', ' vat ', 'nip '],
+    '#KartaKredytowa': ['karta kredytowa', 'kartą kredytową', 'credit card'],
+    '#Kredyt': ['kredyt', 'pożyczka', 'mortgage', 'loan'],
+    '#Podatki': ['podatek', ' pit ', ' cit ', 'urząd skarbowy', 'tax return'],
+    '#RODO': ['rodo', 'gdpr', 'dane osobowe', 'rozporządzenie o ochronie danych', 'personal data'],
+    '#Zdrowie': ['nfz', ' zus ', 'lekarz', 'recepta', 'apteka', 'medical', 'prescription'],
+    '#PrawdopodobnaKopia': ['copy', ' kopia', 'duplikat', 'duplicate', '(1)', '(2)', '(3)', '(4)', '(5)', ' 2.', ' 3.'],
+};
+export const DEFAULT_PATH_RULES = [
+    { pattern: '\\bbank\\b|iban|rachunek', flags: 'i', tags: ['#Bank'] },
+    { pattern: 'faktura|invoice', flags: 'i', tags: ['#Faktura'] },
+    { pattern: 'proforma', flags: 'i', tags: ['#FakturaProforma'] },
+    { pattern: 'wyci.g|wyciag|statement', flags: 'i', tags: ['#Wyciag', '#Bank'] },
+    { pattern: 'karta.kredyt|kredyt.kart|credit.card', flags: 'i', tags: ['#KartaKredytowa', '#Bank'] },
+    { pattern: 'kredyt|po.yczka|loan|mortgage', flags: 'i', tags: ['#Kredyt'] },
+    { pattern: 'podatek|\\bpit\\b|\\bcit\\b|urz.d.skarbow|tax.return', flags: 'i', tags: ['#Podatki'] },
+    { pattern: 'RODO|GDPR|ochrona.danych|personal.data', flags: 'i', tags: ['#RODO'] },
+    { pattern: 'NFZ|ZUS|recepta|apteka|prescription|medical', flags: 'i', tags: ['#Zdrowie'] },
+    { pattern: 'reklamacj|complaint', flags: 'i', tags: ['#Reklamacja'] },
+    { pattern: '\\bskarg', flags: 'i', tags: ['#Skarga'] },
+    { pattern: 'umow[ae]|contract', flags: 'i', tags: ['#Umowa'] },
+    { pattern: 'oferta|offer|proposal', flags: 'i', tags: ['#Oferta'] },
+    { pattern: 'wniosek|wniosk|application', flags: 'i', tags: ['#Wniosek'] },
+    { pattern: 'harmonogram|schedule|timeline', flags: 'i', tags: ['#Harmonogram'] },
+    { pattern: 'oswiadczen|o.wiadczen|statement.of', flags: 'i', tags: ['#Oswiadczenie'] },
+    { pattern: 'decyzja|decyzj|decision', flags: 'i', tags: ['#Decyzja'] },
+    { pattern: 'protokol|protok..|protocol|minutes', flags: 'i', tags: ['#Protokol'] },
+    { pattern: 'ugoda|settlement', flags: 'i', tags: ['#Ugoda'] },
+    { pattern: 'regulamin|terms|\\btos\\b', flags: 'i', tags: ['#Regulamin'] },
+    { pattern: 'pismo|letter|correspondence', flags: 'i', tags: ['#Pismo'] },
+    { pattern: '\\bcv\\b|resume|curriculum.vitae', flags: 'i', tags: ['#CV', '#Kariera'] },
+    { pattern: 'linkedin|kariera|career', flags: 'i', tags: ['#Kariera'] },
+    { pattern: 'mieszkanie|nieruchomo|apartment|property|real.estate', flags: 'i', tags: ['#Nieruchomosc'] },
+    { pattern: 'screenshot|zrzut.ekranu', flags: 'i', tags: ['#Screenshot'] },
+    { pattern: 'nagranie|recording|screen.rec', flags: 'i', tags: ['#Nagranie'] },
+    { pattern: 'za..[aą]cznik|attachment|enclosure', flags: 'i', tags: ['#Zalacznik'] },
+    { pattern: '\\bIMG[\\ _-]?\\d+|\\bphoto\\b|\\bfoto\\b', flags: 'i', tags: ['#Foto'] },
+    { pattern: '[\\ \\-_](?:kopia|copy|duplikat)[\\ \\-_.]|\\(\\d+\\)', flags: 'i', tags: ['#PrawdopodobnaKopia'] },
+];
+export const DEFAULT_CONTEXT = 'EDIT ME in ~/.config/sortai/config.json. 1-2 sentence description of yourself and ongoing matters — ' +
+    '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_CONFIG = {
+    scan: {
+        folder: '~/Desktop',
+        excludeFolders: ['node_modules', '.git', '.cache'],
+        skipExtensions: ['.ds_store', '.sig', '.localized', '.tmp', '.lock', '.pyc'],
+        ocrExtensions: ['.pdf', '.png', '.jpg', '.jpeg', '.webp', '.heic'],
+        videoExtensions: ['.mov', '.mp4', '.m4v'],
+    },
+    ocr: {
+        maxChars: 4000,
+        llmMaxChars: 1500,
+        startPage: 1,
+        maxPages: 2,
+    },
+    llm: {
+        provider: 'ollama',
+        model: 'mistral-nemo',
+        temperature: 0.15,
+        numPredict: 300,
+        ollamaUrl: 'http://localhost:11434',
+    },
+    mask: {
+        enabled: false,
+        lang: 'pl',
+    },
+    dedup: {
+        enabled: true,
+        maxFileSizeMB: 200,
+    },
+    tags: {
+        allowed: DEFAULT_ALLOWED_TAGS,
+        strict: DEFAULT_STRICT_TAGS,
+        aliases: DEFAULT_TAG_ALIASES,
+        strictEvidence: DEFAULT_STRICT_EVIDENCE,
+        pathRules: DEFAULT_PATH_RULES,
+        autoTag: '#AI_Sorted',
+    },
+    context: DEFAULT_CONTEXT,
+};
+export const BAD_COMMENT_PHRASES = [
+    'brak danych',
+    'brak pewnych danych',
+    'brak tekstu',
+    'plik graficzny',
+    'plik wideo',
+    'rak informacji',
+];

package/dist/llm/cloud.js

@@ -0,0 +1,67 @@
+import Anthropic from '@anthropic-ai/sdk';
+export class CloudLlmError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'CloudLlmError';
+    }
+}
+const SYSTEM_PROMPT = 'You receive a Polish/English file-classification task. Respond with ONLY a valid JSON object ' +
+    'matching {"tags": ["#Tag", ...], "comment": "..."}. No markdown, no commentary.';
+export async function callAnthropic(prompt, cfg) {
+    if (!cfg.llm.apiKey) {
+        throw new CloudLlmError('Missing API key for Anthropic provider. Pass --api-key or set ANTHROPIC_API_KEY.');
+    }
+    const client = new Anthropic({ apiKey: cfg.llm.apiKey });
+    try {
+        const msg = await client.messages.create({
+            model: cfg.llm.model,
+            max_tokens: Math.max(cfg.llm.numPredict, 512),
+            temperature: cfg.llm.temperature,
+            system: SYSTEM_PROMPT,
+            messages: [{ role: 'user', content: prompt }],
+        });
+        const text = msg.content
+            .filter((b) => b.type === 'text')
+            .map(b => b.text)
+            .join('\n')
+            .trim();
+        return text;
+    }
+    catch (err) {
+        const m = err instanceof Error ? err.message : String(err);
+        throw new CloudLlmError(`Anthropic call failed: ${m}`);
+    }
+}
+export async function callOpenAi(prompt, cfg) {
+    if (!cfg.llm.apiKey) {
+        throw new CloudLlmError('Missing API key for OpenAI provider. Pass --api-key or set OPENAI_API_KEY.');
+    }
+    try {
+        const res = await fetch('https://api.openai.com/v1/chat/completions', {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                Authorization: `Bearer ${cfg.llm.apiKey}`,
+            },
+            body: JSON.stringify({
+                model: cfg.llm.model,
+                temperature: cfg.llm.temperature,
+                max_tokens: Math.max(cfg.llm.numPredict, 512),
+                response_format: { type: 'json_object' },
+                messages: [
+                    { role: 'system', content: SYSTEM_PROMPT },
+                    { role: 'user', content: prompt },
+                ],
+            }),
+        });
+        if (!res.ok) {
+            throw new Error(`OpenAI HTTP ${res.status}: ${await res.text().catch(() => '')}`);
+        }
+        const data = (await res.json());
+        return (data.choices?.[0]?.message?.content ?? '').trim();
+    }
+    catch (err) {
+        const m = err instanceof Error ? err.message : String(err);
+        throw new CloudLlmError(`OpenAI call failed: ${m}`);
+    }
+}

package/dist/llm/index.js

@@ -0,0 +1,127 @@
+import { mergeTags, normalizeTag, isStrictTag, strictTagHasEvidence } from '../tags.js';
+import { BAD_COMMENT_PHRASES } from '../defaults.js';
+import { buildPrompt, parseJsonSafe } from './prompt.js';
+import { callOllama } from './local.js';
+import { callAnthropic, callOpenAi } from './cloud.js';
+async function dispatchProvider(prompt, cfg) {
+    switch (cfg.llm.provider) {
+        case 'anthropic':
+            return callAnthropic(prompt, cfg);
+        case 'openai':
+            return callOpenAi(prompt, cfg);
+        case 'ollama':
+        default:
+            return callOllama(prompt, cfg);
+    }
+}
+export async function inferTagsAndComment(req, cfg, masker) {
+    const fallback = {
+        tags: mergeTags(cfg, req.preTags).slice(0, 6),
+        comment: `Plik: ${req.fileName}.`,
+    };
+    let promptOcr = req.ocrText;
+    let sessionId = '';
+    if (masker && req.ocrText.trim()) {
+        try {
+            const m = await masker.mask(req.ocrText);
+            promptOcr = m.maskedText;
+            sessionId = m.sessionId;
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            process.stderr.write(`  ⚠️  Mask failed, sending raw OCR: ${msg}\n`);
+        }
+    }
+    const prompt = buildPrompt(req, cfg, promptOcr);
+    let raw;
+    try {
+        raw = await dispatchProvider(prompt, cfg);
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        process.stderr.write(`  ⚠️  ${msg}\n`);
+        return fallback;
+    }
+    if (!raw)
+        return fallback;
+    const data = parseJsonSafe(raw);
+    const rawTags = Array.isArray(data.tags) ? data.tags : [];
+    const evidence = (req.fileName + ' ' + req.ocrText).toLowerCase();
+    const cleaned = [];
+    for (const t of rawTags) {
+        const n = normalizeTag(t, cfg);
+        if (!n)
+            continue;
+        if (isStrictTag(n, cfg)) {
+            if (strictTagHasEvidence(n, evidence, cfg))
+                cleaned.push(n);
+        }
+        else {
+            cleaned.push(n);
+        }
+    }
+    applyContextualGuards(cleaned, req, cfg, evidence);
+    const strictFound = cleaned.filter(t => isStrictTag(t, cfg));
+    const restLlm = cleaned.filter(t => !isStrictTag(t, cfg));
+    let final = mergeTags(cfg, strictFound, req.preTags, restLlm);
+    if (req.ext === '.pdf' && req.ocrText.trim() && !final.includes('#Skan')) {
+        final = mergeTags(cfg, final, ['#Skan']);
+    }
+    let comment = typeof data.comment === 'string' ? data.comment.trim() : '';
+    if (isBadComment(comment)) {
+        comment = `Plik: ${req.fileName}.`;
+    }
+    if (masker && sessionId && comment) {
+        try {
+            comment = await masker.unmask(comment, sessionId);
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            process.stderr.write(`  ⚠️  Unmask failed: ${msg}\n`);
+        }
+    }
+    return {
+        tags: final.slice(0, 6),
+        comment: comment.slice(0, 500),
+    };
+}
+function isBadComment(c) {
+    if (!c)
+        return true;
+    const low = c.toLowerCase();
+    if (BAD_COMMENT_PHRASES.some(p => low.includes(p)))
+        return true;
+    if (low.length < 10)
+        return true;
+    return false;
+}
+function applyContextualGuards(cleaned, req, cfg, evidence) {
+    const financialBlock = new Set(['#Bank', '#Kredyt', '#KartaKredytowa', '#Wyciag', '#Podatki']);
+    const preSet = new Set(req.preTags);
+    const isCv = preSet.has('#CV');
+    const noOcr = !req.ocrText.trim() && ['.png', '.jpg', '.jpeg', '.webp', '.heic'].includes(req.ext);
+    const remove = (predicate) => {
+        for (let i = cleaned.length - 1; i >= 0; i--) {
+            if (predicate(cleaned[i]))
+                cleaned.splice(i, 1);
+        }
+    };
+    if (isCv)
+        remove(t => financialBlock.has(t));
+    const strictSet = new Set(cfg.tags.strict);
+    if (noOcr)
+        remove(t => strictSet.has(t));
+    if (cleaned.includes('#Bank')) {
+        const bankKeywords = ['bank', 'iban', 'rachunek', 'wyciąg', 'prowizja', 'account'];
+        if (!bankKeywords.some(k => evidence.includes(k))) {
+            const idx = cleaned.indexOf('#Bank');
+            if (idx >= 0)
+                cleaned.splice(idx, 1);
+        }
+    }
+    if (cleaned.includes('#Grafika') && cleaned.includes('#CV')) {
+        const idx = cleaned.indexOf('#CV');
+        if (idx >= 0)
+            cleaned.splice(idx, 1);
+    }
+}

package/dist/llm/local.js

@@ -0,0 +1,43 @@
+export class OllamaUnavailableError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'OllamaUnavailableError';
+    }
+}
+export async function callOllama(prompt, cfg, timeoutMs = 90_000) {
+    const url = `${cfg.llm.ollamaUrl.replace(/\/$/, '')}/api/generate`;
+    const controller = new AbortController();
+    const t = setTimeout(() => controller.abort(), timeoutMs);
+    try {
+        const res = await fetch(url, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({
+                model: cfg.llm.model,
+                prompt,
+                stream: false,
+                format: 'json',
+                options: {
+                    temperature: cfg.llm.temperature,
+                    num_predict: cfg.llm.numPredict,
+                },
+            }),
+            signal: controller.signal,
+        });
+        if (!res.ok) {
+            throw new Error(`Ollama HTTP ${res.status}: ${await res.text().catch(() => '')}`);
+        }
+        const data = (await res.json());
+        return (data.response ?? '').trim();
+    }
+    catch (err) {
+        if (err instanceof Error && err.name === 'AbortError') {
+            throw new OllamaUnavailableError(`Ollama timeout after ${timeoutMs}ms at ${url}`);
+        }
+        const msg = err instanceof Error ? err.message : String(err);
+        throw new OllamaUnavailableError(`Ollama call failed: ${msg}`);
+    }
+    finally {
+        clearTimeout(t);
+    }
+}

package/dist/llm/prompt.js

@@ -0,0 +1,75 @@
+export function buildPrompt(req, cfg, ocrTextForPrompt) {
+    const preStr = req.preTags.length > 0 ? req.preTags.join(', ') : 'brak';
+    const ocrTrim = ocrTextForPrompt.slice(0, cfg.ocr.llmMaxChars).trim() ||
+        '(brak tekstu – plik graficzny/wideo)';
+    const strictSet = new Set(cfg.tags.strict);
+    const autoTag = cfg.tags.autoTag;
+    const safeList = cfg.tags.allowed
+        .filter(t => !strictSet.has(t) && t !== autoTag)
+        .sort();
+    const strictList = [...cfg.tags.strict].sort();
+    return [
+        'Klasyfikujesz prywatne pliki w języku polskim i angielskim. Bądź OSTROŻNY i PRECYZYJNY.',
+        'Zwróć WYŁĄCZNIE poprawny JSON (bez markdown, bez komentarzy):',
+        '{"tags": ["#Tag1", "#Tag2"], "comment": "..."}',
+        '',
+        'PLIK:',
+        `- nazwa: ${req.fileName}`,
+        `- rozszerzenie: ${req.ext}`,
+        `- pre_tags (z nazwy/ścieżki/OCR – ZAWSZE uwzględnij): ${preStr}`,
+        `- tekst z dokumentu (OCR):`,
+        ocrTrim,
+        '',
+        'KONTEKST (tylko informacyjnie):',
+        cfg.context,
+        '',
+        'ZASADY TAGOWANIA:',
+        '1. Zawsze uwzględnij wszystkie pre_tags.',
+        '2. Tagi BEZPIECZNE dodaj jeśli wynikają z OCR lub nazwy.',
+        '3. Tagi STRICT dodaj TYLKO gdy słowo kluczowe DOSŁOWNIE występuje w OCR/nazwie',
+        '   (lista evidence keywords per-tag jest w configu w polu strictEvidence).',
+        '   BEZ DOWODU W TEKŚCIE – NIE DODAWAJ tagu strict.',
+        '4. Zwróć 2-5 tagów.',
+        '5. Bez tekstu OCR: użyj tylko pre_tags + #Grafika/#Foto.',
+        '',
+        'ZASADY KOMENTARZA:',
+        '- Napisz JEDNO konkretne zdanie po polsku opisujące WYŁĄCZNIE ten plik.',
+        '- Komentarz musi wynikać z nazwy pliku lub treści OCR – nie wymyślaj.',
+        '- NIE używaj żadnych przykładów z tej instrukcji jako komentarza.',
+        "- Format: co to jest + czego dotyczy.",
+        "  Dla CV: 'CV z [rok] – [krótki kontekst, np. branża].'",
+        "  Dla faktury: 'Faktura od [wystawca] za [usługa].'",
+        "  Dla pisma z banku: 'Pismo z [bank] dotyczące [temat].'",
+        "  Dla grafiki bez tekstu: 'Grafika: [co widać na podstawie nazwy pliku].'",
+        '',
+        'TAGI BEZPIECZNE:',
+        safeList.join('\n'),
+        '',
+        'TAGI STRICT (tylko z dowodem w OCR/nazwie):',
+        strictList.join('\n'),
+        '',
+        'RESTRYKCJE:',
+        '1. Jeśli OCR ma < 10 słów, użyj #Grafika i krótkiego komentarza opartego o nazwę pliku – nie zgaduj treści dokumentu.',
+        '2. Komentarz musi być UNIKALNY. Nie używaj frazy "[rok]". Jeśli nie znasz daty, nie pisz o niej.',
+        '3. BĄDŹ SCEPTYCZNY. Lepiej dać 1 tag (#Grafika) niż 5 błędnych.',
+    ].join('\n');
+}
+export function parseJsonSafe(raw) {
+    const cleaned = raw.trim();
+    try {
+        return JSON.parse(cleaned);
+    }
+    catch {
+        // fall through
+    }
+    const match = cleaned.match(/\{[\s\S]*\}/);
+    if (match) {
+        try {
+            return JSON.parse(match[0]);
+        }
+        catch {
+            return {};
+        }
+    }
+    return {};
+}

package/dist/macos.js

@@ -0,0 +1,55 @@
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+import { promises as fs } from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+import { randomBytes } from 'node:crypto';
+const execFileAsync = promisify(execFile);
+const XATTR_TAGS = 'com.apple.metadata:_kMDItemUserTags';
+const XATTR_COMMENT = 'com.apple.metadata:kMDItemFinderComment';
+function escapeXml(s) {
+    return s
+        .replace(/&/g, '&')
+        .replace(/</g, '&lt;')
+        .replace(/>/g, '&gt;');
+}
+async function writeBinaryPlistXattr(filePath, attr, plistXml) {
+    const tmp = path.join(os.tmpdir(), `sortai-${randomBytes(6).toString('hex')}.plist`);
+    await fs.writeFile(tmp, plistXml, 'utf8');
+    try {
+        await execFileAsync('plutil', ['-convert', 'binary1', tmp], { timeout: 5_000 });
+        const hex = (await fs.readFile(tmp)).toString('hex');
+        await execFileAsync('xattr', ['-wx', attr, hex, filePath], { timeout: 5_000 });
+    }
+    finally {
+        await fs.unlink(tmp).catch(() => { });
+    }
+}
+export async function clearMacosMetadata(filePath) {
+    await execFileAsync('xattr', ['-d', XATTR_TAGS, filePath], { timeout: 5_000 }).catch(() => { });
+    await execFileAsync('xattr', ['-d', XATTR_COMMENT, filePath], { timeout: 5_000 }).catch(() => { });
+}
+export async function setMacosTags(filePath, tags) {
+    if (tags.length === 0)
+        return;
+    const items = tags.map(t => `  <string>${escapeXml(t)}\n0</string>`).join('\n');
+    const plistXml = `<?xml version="1.0" encoding="UTF-8"?>\n` +
+        `<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">\n` +
+        `<plist version="1.0">\n<array>\n${items}\n</array>\n</plist>\n`;
+    await writeBinaryPlistXattr(path.resolve(filePath), XATTR_TAGS, plistXml);
+}
+export async function setFinderComment(filePath, comment) {
+    const trimmed = comment.slice(0, 500).trim();
+    if (!trimmed)
+        return;
+    const plistXml = `<?xml version="1.0" encoding="UTF-8"?>\n` +
+        `<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">\n` +
+        `<plist version="1.0">\n<string>${escapeXml(trimmed)}</string>\n</plist>\n`;
+    await writeBinaryPlistXattr(path.resolve(filePath), XATTR_COMMENT, plistXml);
+}
+export async function writeFileMetadata(filePath, tags, comment) {
+    await clearMacosMetadata(filePath);
+    await setMacosTags(filePath, tags);
+    await setFinderComment(filePath, comment);
+    execFile('mdimport', [filePath], { timeout: 5_000 }, () => { });
+}

package/dist/mask.js

@@ -0,0 +1,83 @@
+import { Client } from '@modelcontextprotocol/sdk/client/index.js';
+import { StdioClientTransport } from '@modelcontextprotocol/sdk/client/stdio.js';
+export class MaskError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'MaskError';
+    }
+}
+export class Masker {
+    client = null;
+    transport = null;
+    cfg;
+    constructor(cfg) {
+        this.cfg = cfg;
+    }
+    async connect() {
+        if (this.client)
+            return;
+        this.transport = new StdioClientTransport({
+            command: 'npx',
+            args: ['-y', 'pseudonym-mcp', '--lang', this.cfg.mask.lang, '--engines', 'hybrid'],
+        });
+        this.client = new Client({ name: 'sortai', version: '0.1.0' }, { capabilities: {} });
+        try {
+            await this.client.connect(this.transport);
+        }
+        catch (err) {
+            this.client = null;
+            const m = err instanceof Error ? err.message : String(err);
+            throw new MaskError(`Failed to start pseudonym-mcp: ${m}`);
+        }
+    }
+    async mask(text) {
+        if (!this.client)
+            throw new MaskError('Masker not connected. Call connect() first.');
+        const result = await this.client.callTool({
+            name: 'mask_text',
+            arguments: { text },
+        });
+        const parsed = extractJson(result);
+        const maskedText = typeof parsed.masked_text === 'string' ? parsed.masked_text : text;
+        const sessionId = typeof parsed.session_id === 'string' ? parsed.session_id : '';
+        return { maskedText, sessionId };
+    }
+    async unmask(text, sessionId) {
+        if (!this.client)
+            throw new MaskError('Masker not connected. Call connect() first.');
+        if (!sessionId)
+            return text;
+        const result = await this.client.callTool({
+            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;
+    }
+    async close() {
+        if (this.client) {
+            await this.client.close().catch(() => undefined);
+            this.client = null;
+        }
+        this.transport = null;
+    }
+}
+function extractJson(result) {
+    if (!result || typeof result !== 'object')
+        return {};
+    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 {};
+    try {
+        const parsed = JSON.parse(textBlock.text);
+        return parsed && typeof parsed === 'object' ? parsed : {};
+    }
+    catch {
+        return {};
+    }
+}

package/dist/ocr.js

@@ -0,0 +1,19 @@
+import path from 'node:path';
+import { ocr } from 'macos-vision';
+export async function extractOcrText(filePath, cfg) {
+    const ext = path.extname(filePath).toLowerCase();
+    if (!cfg.scan.ocrExtensions.includes(ext))
+        return '';
+    try {
+        const text = (await ocr(filePath, {
+            startPage: cfg.ocr.startPage,
+            maxPages: cfg.ocr.maxPages,
+        }));
+        return text.slice(0, cfg.ocr.maxChars);
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        process.stderr.write(`  ⚠️  OCR error for ${filePath}: ${msg}\n`);
+        return '';
+    }
+}

package/dist/pretag.js

@@ -0,0 +1,33 @@
+import path from 'node:path';
+import { mergeTags } from './tags.js';
+export function preTagFromPath(filePath, ocrText, cfg) {
+    const haystack = filePath
+        .replace(/[\\/]/g, ' ')
+        .replace(/_/g, ' ')
+        .replace(/-/g, ' ') +
+        ' ' + ocrText;
+    let collected = [];
+    for (const rule of cfg.tags.pathRules) {
+        let re;
+        try {
+            re = new RegExp(rule.pattern, rule.flags ?? '');
+        }
+        catch {
+            continue;
+        }
+        if (re.test(haystack)) {
+            collected = mergeTags(cfg, collected, rule.tags);
+        }
+    }
+    const ext = path.extname(filePath).toLowerCase();
+    if (ext === '.eml') {
+        collected = mergeTags(cfg, collected, ['#Email']);
+    }
+    else if (cfg.scan.videoExtensions.includes(ext)) {
+        collected = mergeTags(cfg, collected, ['#Nagranie']);
+    }
+    else if (['.png', '.jpg', '.jpeg', '.webp', '.heic'].includes(ext) && !ocrText.trim()) {
+        collected = mergeTags(cfg, collected, ['#Grafika']);
+    }
+    return collected;
+}

package/dist/tags.js

@@ -0,0 +1,36 @@
+export function normalizeTag(raw, cfg) {
+    if (typeof raw !== 'string')
+        return null;
+    let tag = raw.trim();
+    if (!tag)
+        return null;
+    if (!tag.startsWith('#'))
+        tag = '#' + tag;
+    tag = cfg.tags.aliases[tag] ?? tag;
+    const allowed = new Set([...cfg.tags.allowed, cfg.tags.autoTag]);
+    return allowed.has(tag) ? tag : null;
+}
+export function mergeTags(cfg, ...lists) {
+    const seen = [];
+    for (const list of lists) {
+        if (!list)
+            continue;
+        for (const raw of list) {
+            const normalized = normalizeTag(raw, cfg);
+            if (normalized && !seen.includes(normalized)) {
+                seen.push(normalized);
+            }
+        }
+    }
+    return seen;
+}
+export function isStrictTag(tag, cfg) {
+    return cfg.tags.strict.includes(tag);
+}
+export function strictTagHasEvidence(tag, evidence, cfg) {
+    const keywords = cfg.tags.strictEvidence[tag] ?? [];
+    if (keywords.length === 0)
+        return false;
+    const haystack = evidence.toLowerCase();
+    return keywords.some(kw => haystack.includes(kw.toLowerCase()));
+}

package/dist/types.js

@@ -0,0 +1 @@
+export {};