clawsouls 0.13.6 → 0.14.0

package/dist/bin/clawsouls.js

@@ -14,6 +14,7 @@ import { soulscanCommand } from '../commands/soulscan.js';
 import { scanCommand as localScanCommand } from '../commands/scan.js';
 import { platformCommand } from '../commands/platform.js';
 import { exportCommand } from '../commands/export.js';
+import { importCommand } from '../commands/import.js';
 import { syncInitCommand, syncPushCommand, syncPullCommand, syncStatusCommand, syncExportKeyCommand, syncImportKeyCommand } from '../commands/sync.js';
 import { versionBumpCommand } from '../commands/version.js';
 import { diffCommand } from '../commands/diff.js';
@@ -44,7 +45,7 @@ program
     .command('install <name>')
     .description('Install a soul from the registry')
     .option('-f, --force', 'Overwrite if already installed')
-    .option('--use <platform>', 'Auto-activate after install (claude-code, cursor, windsurf, openclaw)')
+    .option('--use <platform>', 'Auto-activate after install (claude-code, cursor, windsurf, openclaw, hermes)')
     .action(installCommand);
 program
     .command('use <name>')
@@ -119,6 +120,16 @@ program
     .option('-o, --output <path>', 'Output file path')
     .option('-d, --dir <path>', 'Source soul directory (default: active workspace)')
     .action((format, opts) => exportCommand(format, opts));
+program
+    .command('import <format>')
+    .description('Import persona from other formats (claude-md, system-prompt, cursorrules)')
+    .option('-i, --input <path>', 'Source file path (default: auto-detect)')
+    .option('-o, --output <path>', 'Output directory (default: ./)')
+    .option('--dry-run', 'Preview classification without writing files')
+    .option('--smart', 'Use LLM-assisted classification (requires API key)')
+    .option('--name <name>', 'Soul name for soul.json')
+    .option('-f, --force', 'Overwrite existing files')
+    .action((format, opts) => importCommand(format, opts));
 // ─── Sync Commands ───────────────────────────────────────
 const sync = program
     .command('sync')
@@ -387,4 +398,3 @@ swKeys.command('rotate')
     catch { /* ignore — don't block CLI on network issues */ }
 })();
 program.parse();
-//# sourceMappingURL=clawsouls.js.map

package/dist/commands/__tests__/init.test.js

@@ -58,4 +58,3 @@ describe('clawsouls init --spec', () => {
         expect(console.error).toHaveBeenCalledWith(expect.stringContaining('already exists'));
     });
 });
-//# sourceMappingURL=init.test.js.map

package/dist/commands/checkpoint.js

@@ -433,4 +433,3 @@ export async function checkpointScanCommand(dir, opts) {
     }
     console.log('');
 }
-//# sourceMappingURL=checkpoint.js.map

package/dist/commands/diff.js

@@ -62,4 +62,3 @@ export async function diffCommand(soul, v1, v2) {
         chalk.green(`+${totalAdditions} additions`) + ', ' +
         chalk.red(`-${totalDeletions} deletions`));
 }
-//# sourceMappingURL=diff.js.map

package/dist/commands/doctor.js

@@ -127,4 +127,3 @@ export async function doctorCommand() {
     }
     console.log();
 }
-//# sourceMappingURL=doctor.js.map

package/dist/commands/export.js

@@ -157,4 +157,3 @@ export async function exportCommand(format, options) {
         console.log(chalk.dim('  2. Claude Code picks it up automatically'));
     }
 }
-//# sourceMappingURL=export.js.map

package/dist/commands/import.d.ts

@@ -0,0 +1,9 @@
+export interface ImportOptions {
+    input?: string;
+    output?: string;
+    dryRun?: boolean;
+    smart?: boolean;
+    name?: string;
+    force?: boolean;
+}
+export declare function importCommand(format: string, options: ImportOptions): Promise<void>;

package/dist/commands/import.js

@@ -0,0 +1,218 @@
+import chalk from 'chalk';
+import { existsSync, readFileSync, writeFileSync, statSync } from 'fs';
+import { join, resolve, basename } from 'path';
+import { parseMarkdown } from '../import/parser.js';
+import { classifySections } from '../import/classifier.js';
+import { convertSections, estimateSize } from '../import/converter.js';
+import { generateSoulJson } from '../import/soul-json-generator.js';
+const SUPPORTED_FORMATS = ['claude-md', 'system-prompt', 'cursorrules', 'windsurfrules'];
+/**
+ * Auto-detect input file based on format.
+ */
+function autoDetectInput(format, cwd) {
+    switch (format) {
+        case 'claude-md':
+            for (const candidate of ['CLAUDE.md', 'claude.md']) {
+                const p = join(cwd, candidate);
+                if (existsSync(p))
+                    return p;
+            }
+            return null;
+        case 'cursorrules':
+            for (const candidate of ['.cursorrules', '.cursor/rules/persona.md', '.cursor/rules/main.md']) {
+                const p = join(cwd, candidate);
+                if (existsSync(p))
+                    return p;
+            }
+            return null;
+        case 'windsurfrules':
+            for (const candidate of ['.windsurfrules']) {
+                const p = join(cwd, candidate);
+                if (existsSync(p))
+                    return p;
+            }
+            return null;
+        case 'system-prompt':
+            for (const candidate of ['system-prompt.txt', 'system_prompt.txt', 'prompt.txt']) {
+                const p = join(cwd, candidate);
+                if (existsSync(p))
+                    return p;
+            }
+            return null;
+        default:
+            return null;
+    }
+}
+/**
+ * For system-prompt format: wrap entire content in a single SOUL.md section.
+ */
+function importAsSystemPrompt(content) {
+    const sections = parseMarkdown(content);
+    if (sections.length === 0) {
+        return [{
+                heading: '',
+                content,
+                level: 0,
+                lineStart: 0,
+                target: 'SOUL.md',
+                confidence: 80,
+                reason: 'system-prompt: entire content',
+            }];
+    }
+    // Classify normally but bump all to SOUL.md
+    return classifySections(sections).map(s => ({
+        ...s,
+        target: 'SOUL.md',
+        confidence: 70,
+        reason: 'system-prompt format: routed to SOUL.md',
+    }));
+}
+function formatBytes(n) {
+    if (n < 1024)
+        return `${n} B`;
+    return `${(n / 1024).toFixed(1)} KB`;
+}
+function confidenceColor(n) {
+    if (n >= 80)
+        return chalk.green(`${n}%`);
+    if (n >= 60)
+        return chalk.yellow(`${n}%`);
+    return chalk.red(`${n}%`) + chalk.dim(' ⚠ low confidence');
+}
+function targetColor(target) {
+    switch (target) {
+        case 'SOUL.md': return chalk.magenta(target);
+        case 'IDENTITY.md': return chalk.cyan(target);
+        case 'AGENTS.md': return chalk.blue(target);
+        case 'STYLE.md': return chalk.yellow(target);
+        case 'HEARTBEAT.md': return chalk.green(target);
+        case 'RULES.md': return chalk.red(target);
+        case 'TOOLS.md': return chalk.gray(target);
+        case 'SKIP': return chalk.dim('SKIP');
+        default: return target;
+    }
+}
+export async function importCommand(format, options) {
+    if (!SUPPORTED_FORMATS.includes(format)) {
+        console.error(chalk.red(`Unknown format: "${format}"`));
+        console.error(`Supported formats: ${SUPPORTED_FORMATS.join(', ')}`);
+        process.exit(1);
+    }
+    const cwd = process.cwd();
+    const outputDir = resolve(options.output || cwd);
+    // Resolve input file
+    let inputPath;
+    if (options.input) {
+        inputPath = resolve(options.input);
+    }
+    else {
+        const detected = autoDetectInput(format, cwd);
+        if (!detected) {
+            console.error(chalk.red(`Could not auto-detect input file for format "${format}"`));
+            console.error(`Use --input <path> to specify the file.`);
+            process.exit(1);
+        }
+        inputPath = detected;
+    }
+    if (!existsSync(inputPath)) {
+        console.error(chalk.red(`File not found: ${inputPath}`));
+        process.exit(1);
+    }
+    const content = readFileSync(inputPath, 'utf-8');
+    const fileSize = statSync(inputPath).size;
+    // Parse
+    const rawSections = parseMarkdown(content);
+    console.log('');
+    console.log(chalk.bold(`Analyzing: ${chalk.cyan(basename(inputPath))} `) +
+        chalk.dim(`(${formatBytes(fileSize)}, ${rawSections.length} section${rawSections.length !== 1 ? 's' : ''})`));
+    console.log('');
+    // Classify
+    let classified = format === 'system-prompt'
+        ? importAsSystemPrompt(content)
+        : classifySections(rawSections);
+    if (options.smart) {
+        console.log(chalk.dim('  --smart: LLM-assisted classification not yet implemented, using rule-based.'));
+    }
+    // Group for summary
+    const grouped = new Map();
+    for (const s of classified) {
+        const arr = grouped.get(s.target) || [];
+        arr.push(s);
+        grouped.set(s.target, arr);
+    }
+    // Print classification table
+    console.log(chalk.bold('Classification Results:'));
+    for (const s of classified) {
+        const heading = s.heading
+            ? s.heading.slice(0, 45).padEnd(46)
+            : chalk.dim('(no heading)'.padEnd(46));
+        const arrow = chalk.dim('→');
+        const target = targetColor(s.target).padEnd(20);
+        const conf = confidenceColor(s.confidence);
+        console.log(`  ${heading} ${arrow} ${target} (confidence: ${conf})`);
+    }
+    console.log('');
+    console.log(chalk.bold('Files to create:'));
+    const allTargets = ['SOUL.md', 'IDENTITY.md', 'AGENTS.md', 'STYLE.md', 'HEARTBEAT.md', 'RULES.md', 'TOOLS.md'];
+    let hasLowConfidence = false;
+    for (const target of allTargets) {
+        const sections = grouped.get(target);
+        if (!sections || sections.length === 0)
+            continue;
+        const sizeStr = formatBytes(estimateSize(sections));
+        const count = sections.length;
+        const isExtras = ['RULES.md', 'TOOLS.md'].includes(target);
+        const label = isExtras ? `extras/${target}` : target;
+        const lowConf = sections.some(s => s.confidence < 60);
+        if (lowConf)
+            hasLowConfidence = true;
+        console.log(`  ${targetColor(target).padEnd(22)} ${String(count).padStart(2)} section${count !== 1 ? 's' : ' '}  (~${sizeStr})`);
+    }
+    console.log(`  ${'soul.json'.padEnd(22)} auto-generated`);
+    const skipCount = (grouped.get('SKIP') || []).length;
+    const lowConfCount = classified.filter(s => s.confidence < 60 && s.target !== 'SKIP').length;
+    console.log('');
+    if (skipCount > 0) {
+        console.log(chalk.dim(`Skipped: ${skipCount} section${skipCount !== 1 ? 's' : ''} (memory/config, not persona)`));
+    }
+    if (lowConfCount > 0) {
+        console.log(chalk.yellow(`Low confidence: ${lowConfCount} section${lowConfCount !== 1 ? 's' : ''} — use --smart for LLM-assisted classification`));
+    }
+    if (options.dryRun) {
+        console.log('');
+        console.log(chalk.dim('Dry run — no files written. Remove --dry-run to create files.'));
+        return;
+    }
+    console.log('');
+    // Write files
+    const result = convertSections(classified, {
+        outputDir,
+        force: options.force,
+        dryRun: false,
+    });
+    // Write soul.json
+    const soulJson = generateSoulJson(classified, { name: options.name });
+    const soulJsonPath = join(outputDir, 'soul.json');
+    if (!existsSync(soulJsonPath) || options.force) {
+        writeFileSync(soulJsonPath, JSON.stringify(soulJson, null, 2) + '\n', 'utf-8');
+        result.written.push(soulJsonPath);
+    }
+    else {
+        result.existing.push(soulJsonPath);
+    }
+    // Summary
+    console.log(chalk.bold('Summary:'));
+    for (const f of result.written) {
+        console.log(`  ${chalk.green('✓')} ${f}`);
+    }
+    if (result.existing.length > 0) {
+        console.log('');
+        console.log(chalk.yellow(`  Skipped (already exist — use --force to overwrite):`));
+        for (const f of result.existing) {
+            console.log(chalk.dim(`    ${f}`));
+        }
+    }
+    console.log('');
+    console.log(chalk.green(`Done! Soul Spec files written to: ${chalk.bold(outputDir)}`));
+    console.log(chalk.dim('  Run `clawsouls validate` to check the generated package.'));
+}

package/dist/commands/info.js

@@ -66,4 +66,3 @@ export async function infoCommand(nameArg) {
     console.log(`\n  ${chalk.cyan(soulUrl)}`);
     console.log(chalk.dim(`\n  Install: ${chalk.cyan(`clawsouls install ${nameArg}`)}\n`));
 }
-//# sourceMappingURL=info.js.map

package/dist/commands/init.js

@@ -250,4 +250,3 @@ export async function initCommand(name, specVersion, environment) {
     console.log(chalk.cyan(`    clawsouls validate .`));
     console.log(chalk.cyan(`    clawsouls publish .`));
 }
-//# sourceMappingURL=init.js.map

package/dist/commands/install.js

@@ -73,6 +73,29 @@ export function applyToPlatform(platform, soulDir, manifest) {
             writeFileSync(target, combined, 'utf-8');
             return target;
         }
+        case 'hermes': {
+            // Hermes Agent: SOUL.md → ~/.hermes/SOUL.md (identity slot #1)
+            // IDENTITY.md + STYLE.md merged into SOUL.md
+            // AGENTS.md → CWD/AGENTS.md (Hermes discovers it automatically)
+            const hermesHome = process.env.HERMES_HOME || join(process.env.HOME || '~', '.hermes');
+            mkdirSync(hermesHome, { recursive: true });
+            // Build combined SOUL.md (soul + identity + style)
+            const hermesSoulSections = [];
+            if (soulText)
+                hermesSoulSections.push(soulText);
+            if (identityText)
+                hermesSoulSections.push(`\n---\n\n${identityText}`);
+            if (styleText)
+                hermesSoulSections.push(`\n---\n\n${styleText}`);
+            const hermesSoulPath = join(hermesHome, 'SOUL.md');
+            writeFileSync(hermesSoulPath, hermesSoulSections.join('\n'), 'utf-8');
+            // AGENTS.md → CWD (Hermes auto-discovers)
+            if (agentsText) {
+                const agentsPath = join(cwd, 'AGENTS.md');
+                writeFileSync(agentsPath, agentsText, 'utf-8');
+            }
+            return hermesSoulPath;
+        }
         case 'openclaw': {
             // Delegate to existing useCommand for OpenClaw workspace
             return ''; // Signal to use existing flow
@@ -142,6 +165,7 @@ export async function installCommand(nameWithVersion, options) {
                     'claude-code': 'Claude Code',
                     'cursor': 'Cursor',
                     'windsurf': 'Windsurf',
+                    'hermes': 'Hermes Agent',
                 };
                 const label = platformLabels[options.use] || options.use;
                 spinner.succeed(`Installed ${chalk.green(displayName)} v${ver} → ${chalk.cyan(label)}\n` +
@@ -160,4 +184,3 @@ export async function installCommand(nameWithVersion, options) {
         process.exit(1);
     }
 }
-//# sourceMappingURL=install.js.map

package/dist/commands/list.js

@@ -18,4 +18,3 @@ export async function listCommand() {
     }
     console.log();
 }
-//# sourceMappingURL=list.js.map

package/dist/commands/login.js

@@ -78,4 +78,3 @@ export async function whoamiCommand() {
         process.exit(1);
     }
 }
-//# sourceMappingURL=login.js.map

package/dist/commands/migrate.js

@@ -71,4 +71,3 @@ export async function migrateCommand(opts) {
     }
     console.log();
 }
-//# sourceMappingURL=migrate.js.map

package/dist/commands/platform.js

@@ -34,4 +34,3 @@ export async function platformCommand() {
     console.log(`  ${getKnownPlatformNames().join(', ')}, or any custom path`);
     console.log();
 }
-//# sourceMappingURL=platform.js.map

package/dist/commands/publish.js

@@ -167,4 +167,3 @@ export async function publishCommand(dir, options) {
         process.exit(1);
     }
 }
-//# sourceMappingURL=publish.js.map

package/dist/commands/restore.js

@@ -20,4 +20,3 @@ export async function restoreCommand() {
         process.exit(1);
     }
 }
-//# sourceMappingURL=restore.js.map

package/dist/commands/scan.js

@@ -216,4 +216,3 @@ function printSemanticFindings(findings, model, durationMs) {
     }
     console.log(chalk.gray(`\n   Model: ${model} | ${durationMs}ms\n`));
 }
-//# sourceMappingURL=scan.js.map

package/dist/commands/search.js

@@ -49,4 +49,3 @@ export async function searchCommand(query) {
     }
     console.log(chalk.dim(`\n  Install with: ${chalk.cyan('clawsouls install owner/name')}\n`));
 }
-//# sourceMappingURL=search.js.map

package/dist/commands/soulscan.js

@@ -508,4 +508,3 @@ function printScanResults(checks) {
     }
     console.log('');
 }
-//# sourceMappingURL=soulscan.js.map

package/dist/commands/swarm.js

@@ -598,4 +598,3 @@ function splitSections(content) {
         sections.push(current.trim());
     return sections;
 }
-//# sourceMappingURL=swarm.js.map

package/dist/commands/sync.js

@@ -320,4 +320,3 @@ export async function syncImportKeyCommand(key) {
         console.log(chalk.red('Invalid key. Could not derive public key.'));
     }
 }
-//# sourceMappingURL=sync.js.map

package/dist/commands/test.js

@@ -327,4 +327,3 @@ export async function testCommand(opts) {
     if (!allPassed)
         process.exit(1);
 }
-//# sourceMappingURL=test.js.map

package/dist/commands/update.js

@@ -70,4 +70,3 @@ export async function updateCommand() {
         console.log(chalk.green('\n  All souls are up to date.\n'));
     }
 }
-//# sourceMappingURL=update.js.map

package/dist/commands/use.js

@@ -95,4 +95,3 @@ export async function useCommand(name, opts) {
         process.exit(1);
     }
 }
-//# sourceMappingURL=use.js.map

package/dist/commands/validate.js

@@ -284,4 +284,3 @@ function printResults(results) {
         console.log(chalk.green.bold('✓ Soul is valid and ready to publish!') + chalk.dim(` (${passed} checks passed)`));
     }
 }
-//# sourceMappingURL=validate.js.map

package/dist/commands/version.js

@@ -42,4 +42,3 @@ export async function versionBumpCommand(type, options) {
     }
     console.log(`✅ Bumped version: ${currentVersion} → ${newVersion}`);
 }
-//# sourceMappingURL=version.js.map

package/dist/import/classifier.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Rule-based classifier for Soul Spec section routing.
+ * Classifies parsed markdown sections into target Soul Spec files.
+ */
+import { Section } from './parser.js';
+export type SoulTarget = 'SOUL.md' | 'IDENTITY.md' | 'AGENTS.md' | 'STYLE.md' | 'HEARTBEAT.md' | 'RULES.md' | 'TOOLS.md' | 'SKIP';
+export interface ClassifiedSection extends Section {
+    target: SoulTarget;
+    confidence: number;
+    reason: string;
+}
+/**
+ * Classify all sections and return enriched array.
+ */
+export declare function classifySections(sections: Section[]): ClassifiedSection[];

package/dist/import/classifier.js

@@ -0,0 +1,156 @@
+/**
+ * Rule-based classifier for Soul Spec section routing.
+ * Classifies parsed markdown sections into target Soul Spec files.
+ */
+import { headingText } from './parser.js';
+const CLASSIFICATION_RULES = [
+    {
+        target: 'SOUL.md',
+        keywords: [
+            'personality', 'character', 'traits', 'values', 'principles',
+            'who you are', 'core beliefs', 'philosophy', 'soul', 'persona',
+            '성격', '원칙', '가치관', '철학', '핵심',
+        ],
+        weight: 1.0,
+    },
+    {
+        target: 'IDENTITY.md',
+        keywords: [
+            'name', 'identity', 'background', 'role', 'creature', 'species',
+            'who am i', 'i am', 'about me',
+            '이름', '정체성', '역할', '배경', '자기소개',
+        ],
+        weight: 1.0,
+    },
+    {
+        target: 'AGENTS.md',
+        keywords: [
+            'workflow', 'work style', 'safety', 'agents', 'protocol', 'procedure',
+            'rules', 'guidelines', 'constraints', 'boundaries', 'limits', 'behavior',
+            'process', 'steps', 'checklist', 'bootstrap', 'session start',
+            '워크플로우', '작업', '안전', '규칙', '절차', '가이드', '제약',
+        ],
+        weight: 1.0,
+    },
+    {
+        target: 'STYLE.md',
+        keywords: [
+            'style', 'tone', 'voice', 'communication', 'language', 'writing',
+            'speak', 'response format', 'format', 'output', 'formatting',
+            '말투', '스타일', '어조', '언어', '커뮤니케이션', '표현',
+        ],
+        weight: 1.0,
+    },
+    {
+        target: 'HEARTBEAT.md',
+        keywords: [
+            'heartbeat', 'periodic', 'cron', 'autonomous', 'check-in', 'schedule',
+            'interval', 'background', 'monitoring', 'health check', 'self-check',
+            '자율', '점검', '주기', '헬스체크', '배경', '크론',
+        ],
+        weight: 1.2, // slightly higher — heartbeat is very distinct
+    },
+    {
+        target: 'RULES.md',
+        keywords: [
+            'do not', "don't", 'never', 'always', 'must', 'forbidden', 'prohibited',
+            'restriction', 'constraint', 'boundary',
+            '금지', '절대', '반드시', '제한',
+        ],
+        weight: 0.9,
+    },
+    {
+        target: 'TOOLS.md',
+        keywords: [
+            'tools', 'permissions', 'allowed', 'access', 'capabilities', 'mcp',
+            'function', 'api', 'integration',
+            '도구', '권한', '허용', '접근', '기능',
+        ],
+        weight: 0.9,
+    },
+];
+/**
+ * Keywords that signal a section should be SKIPPED (not persona content).
+ * These are meta/config sections, not character/persona.
+ */
+const SKIP_KEYWORDS = [
+    'memory', 'context window', 'session', 'bootstrap', 'token',
+    'oh-my-claudecode', 'omc', 'mcp tools', 'hooks', 'state files',
+    'notepad', 'compaction', 'worktree',
+    '메모리', '컨텍스트', '세션', '부트스트랩',
+];
+/**
+ * Check if a section should be skipped based on heading or content.
+ */
+function shouldSkip(heading, content) {
+    const lower = (heading + ' ' + content.slice(0, 300)).toLowerCase();
+    for (const kw of SKIP_KEYWORDS) {
+        if (lower.includes(kw.toLowerCase())) {
+            return { skip: true, confidence: 85 };
+        }
+    }
+    return { skip: false, confidence: 0 };
+}
+/**
+ * Score a section against a rule based on keyword matches in heading + content preview.
+ */
+function scoreSection(heading, content, rule) {
+    const text = (heading + ' ' + content.slice(0, 500)).toLowerCase();
+    let matches = 0;
+    let totalWeight = 0;
+    for (const kw of rule.keywords) {
+        if (text.includes(kw.toLowerCase())) {
+            matches++;
+            totalWeight += kw.split(' ').length > 1 ? 2 : 1; // multi-word keywords score higher
+        }
+    }
+    if (matches === 0)
+        return 0;
+    // Normalize: max score is 100
+    const rawScore = (totalWeight / rule.keywords.length) * 100 * rule.weight;
+    return Math.min(rawScore, 100);
+}
+/**
+ * Classify a single section.
+ */
+function classifySection(section) {
+    const htxt = headingText(section).toLowerCase();
+    const content = section.content;
+    // Skip check first
+    const skipResult = shouldSkip(htxt, content);
+    if (skipResult.skip) {
+        return { target: 'SKIP', confidence: skipResult.confidence, reason: 'memory/config content' };
+    }
+    // Score against all rules
+    const scores = [];
+    for (const rule of CLASSIFICATION_RULES) {
+        const score = scoreSection(htxt, content, rule);
+        if (score > 0) {
+            scores.push({ target: rule.target, score });
+        }
+    }
+    if (scores.length === 0) {
+        // No match — fallback to SOUL.md with low confidence
+        return { target: 'SOUL.md', confidence: 30, reason: 'no keyword match — defaulting to SOUL.md' };
+    }
+    // Pick highest scoring
+    scores.sort((a, b) => b.score - a.score);
+    const best = scores[0];
+    const confidence = Math.round(Math.min(best.score + 20, 100)); // add base boost
+    const matchedRule = CLASSIFICATION_RULES.find(r => r.target === best.target);
+    const matchedKws = matchedRule.keywords.filter(kw => (htxt + ' ' + content.slice(0, 500).toLowerCase()).includes(kw.toLowerCase())).slice(0, 3);
+    return {
+        target: best.target,
+        confidence,
+        reason: `keyword match: ${matchedKws.join(', ')}`,
+    };
+}
+/**
+ * Classify all sections and return enriched array.
+ */
+export function classifySections(sections) {
+    return sections.map(section => {
+        const { target, confidence, reason } = classifySection(section);
+        return { ...section, target, confidence, reason };
+    });
+}

package/dist/import/converter.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Converter: takes classified sections and writes Soul Spec files.
+ */
+import { ClassifiedSection } from './classifier.js';
+interface ConvertOptions {
+    outputDir: string;
+    force?: boolean;
+    dryRun?: boolean;
+}
+interface ConvertResult {
+    written: string[];
+    skipped: string[];
+    existing: string[];
+}
+/**
+ * Write Soul Spec files from classified sections.
+ * Returns a summary of what was written/skipped.
+ */
+export declare function convertSections(sections: ClassifiedSection[], options: ConvertOptions): ConvertResult;
+/**
+ * Estimate byte size of content for a group of sections.
+ */
+export declare function estimateSize(sections: ClassifiedSection[]): number;
+export {};