clawsouls 0.13.7 → 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';
@@ -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')

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/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 {};

package/dist/import/converter.js

@@ -0,0 +1,84 @@
+/**
+ * Converter: takes classified sections and writes Soul Spec files.
+ */
+import { existsSync, mkdirSync, writeFileSync } from 'fs';
+import { join } from 'path';
+const CORE_TARGETS = ['SOUL.md', 'IDENTITY.md', 'AGENTS.md', 'STYLE.md', 'HEARTBEAT.md'];
+const EXTRAS_TARGETS = ['RULES.md', 'TOOLS.md'];
+/**
+ * Group classified sections by their target file.
+ */
+function groupByTarget(sections) {
+    const map = new Map();
+    for (const section of sections) {
+        if (section.target === 'SKIP')
+            continue;
+        const arr = map.get(section.target) || [];
+        arr.push(section);
+        map.set(section.target, arr);
+    }
+    return map;
+}
+/**
+ * Build the markdown content for a Soul Spec file from its sections.
+ */
+function buildFileContent(target, sections) {
+    const lines = [];
+    // File header comment
+    lines.push(`<!-- Generated by clawsouls import -->`);
+    lines.push('');
+    for (const section of sections) {
+        if (section.heading) {
+            lines.push(section.heading);
+            lines.push('');
+        }
+        if (section.content) {
+            lines.push(section.content);
+            lines.push('');
+        }
+    }
+    return lines.join('\n').trimEnd() + '\n';
+}
+/**
+ * Write Soul Spec files from classified sections.
+ * Returns a summary of what was written/skipped.
+ */
+export function convertSections(sections, options) {
+    const { outputDir, force = false, dryRun = false } = options;
+    const grouped = groupByTarget(sections);
+    const result = { written: [], skipped: [], existing: [] };
+    // Ensure output directory exists
+    if (!dryRun && !existsSync(outputDir)) {
+        mkdirSync(outputDir, { recursive: true });
+    }
+    // Write core target files
+    for (const target of [...CORE_TARGETS, ...EXTRAS_TARGETS]) {
+        const targetSections = grouped.get(target);
+        if (!targetSections || targetSections.length === 0) {
+            result.skipped.push(target);
+            continue;
+        }
+        const isExtras = EXTRAS_TARGETS.includes(target);
+        const fileDir = isExtras ? join(outputDir, 'extras') : outputDir;
+        const filePath = join(fileDir, target);
+        if (existsSync(filePath) && !force) {
+            result.existing.push(filePath);
+            continue;
+        }
+        const content = buildFileContent(target, targetSections);
+        if (!dryRun) {
+            if (!existsSync(fileDir)) {
+                mkdirSync(fileDir, { recursive: true });
+            }
+            writeFileSync(filePath, content, 'utf-8');
+        }
+        result.written.push(filePath);
+    }
+    return result;
+}
+/**
+ * Estimate byte size of content for a group of sections.
+ */
+export function estimateSize(sections) {
+    return sections.reduce((acc, s) => acc + s.heading.length + s.content.length + 2, 0);
+}

package/dist/import/parser.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Markdown section parser for clawsouls import
+ * Splits a markdown file into sections by heading level,
+ * while correctly handling code blocks (headings inside ``` are ignored).
+ */
+export interface Section {
+    heading: string;
+    content: string;
+    level: number;
+    lineStart: number;
+}
+/**
+ * Parse markdown text into sections split on headings.
+ * Headings inside fenced code blocks are not treated as section boundaries.
+ */
+export declare function parseMarkdown(text: string): Section[];
+/**
+ * Extract the text of a heading (without # marks and leading/trailing whitespace).
+ */
+export declare function headingText(section: Section): string;

package/dist/import/parser.js

@@ -0,0 +1,79 @@
+/**
+ * Markdown section parser for clawsouls import
+ * Splits a markdown file into sections by heading level,
+ * while correctly handling code blocks (headings inside ``` are ignored).
+ */
+/**
+ * Parse markdown text into sections split on headings.
+ * Headings inside fenced code blocks are not treated as section boundaries.
+ */
+export function parseMarkdown(text) {
+    const lines = text.split('\n');
+    const sections = [];
+    let inCodeBlock = false;
+    let codeBlockFence = '';
+    // Collect heading positions first
+    const headingLines = [];
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        // Detect fenced code block boundaries (``` or ~~~)
+        const fenceMatch = line.match(/^(`{3,}|~{3,})/);
+        if (fenceMatch) {
+            if (!inCodeBlock) {
+                inCodeBlock = true;
+                codeBlockFence = fenceMatch[1][0]; // ` or ~
+            }
+            else if (line.trimEnd().startsWith(codeBlockFence.repeat(3))) {
+                inCodeBlock = false;
+                codeBlockFence = '';
+            }
+            continue;
+        }
+        if (inCodeBlock)
+            continue;
+        // ATX heading match (# through ######)
+        const headingMatch = line.match(/^(#{1,6})\s+(.+)$/);
+        if (headingMatch) {
+            headingLines.push({
+                index: i,
+                level: headingMatch[1].length,
+                heading: line,
+            });
+        }
+    }
+    if (headingLines.length === 0) {
+        // No headings — entire content is one section
+        const content = text.trim();
+        if (content) {
+            sections.push({
+                heading: '',
+                content,
+                level: 0,
+                lineStart: 0,
+            });
+        }
+        return sections;
+    }
+    for (let i = 0; i < headingLines.length; i++) {
+        const { index, level, heading } = headingLines[i];
+        const nextIndex = i + 1 < headingLines.length ? headingLines[i + 1].index : lines.length;
+        const contentLines = lines.slice(index + 1, nextIndex);
+        // trim trailing blank lines
+        while (contentLines.length > 0 && contentLines[contentLines.length - 1].trim() === '') {
+            contentLines.pop();
+        }
+        sections.push({
+            heading,
+            content: contentLines.join('\n'),
+            level,
+            lineStart: index,
+        });
+    }
+    return sections;
+}
+/**
+ * Extract the text of a heading (without # marks and leading/trailing whitespace).
+ */
+export function headingText(section) {
+    return section.heading.replace(/^#{1,6}\s+/, '').trim();
+}

package/dist/import/soul-json-generator.d.ts

@@ -0,0 +1,28 @@
+/**
+ * soul.json generator for clawsouls import.
+ * Extracts metadata from classified sections and produces a v0.6 soul.json.
+ */
+import { ClassifiedSection } from './classifier.js';
+interface SoulAuthor {
+    name: string;
+}
+interface SoulJson {
+    specVersion: string;
+    name: string;
+    displayName: string;
+    version: string;
+    description: string;
+    author: SoulAuthor;
+    category: string;
+    tags: string[];
+    type: string;
+}
+export interface SoulJsonOptions {
+    name?: string;
+    author?: string;
+}
+/**
+ * Generate a soul.json object from classified sections.
+ */
+export declare function generateSoulJson(sections: ClassifiedSection[], opts?: SoulJsonOptions): SoulJson;
+export {};

package/dist/import/soul-json-generator.js

@@ -0,0 +1,133 @@
+/**
+ * soul.json generator for clawsouls import.
+ * Extracts metadata from classified sections and produces a v0.6 soul.json.
+ */
+import { headingText } from './parser.js';
+/**
+ * Convert a display name to a URL-safe slug.
+ */
+function slugify(text) {
+    return text
+        .toLowerCase()
+        .trim()
+        .replace(/[^\w\s-]/g, '')
+        .replace(/[\s_-]+/g, '-')
+        .replace(/^-+|-+$/g, '');
+}
+/**
+ * Extract the first non-empty paragraph from section content.
+ */
+function extractFirstParagraph(content) {
+    const lines = content.split('\n');
+    const paragraphLines = [];
+    for (const line of lines) {
+        const trimmed = line.trim();
+        if (trimmed === '') {
+            if (paragraphLines.length > 0)
+                break;
+            continue;
+        }
+        // Skip headings and list items for description
+        if (trimmed.startsWith('#') || trimmed.startsWith('- ') || trimmed.startsWith('* ')) {
+            if (paragraphLines.length > 0)
+                break;
+            continue;
+        }
+        paragraphLines.push(trimmed);
+    }
+    return paragraphLines.join(' ').slice(0, 200);
+}
+/**
+ * Extract a display name from the soul sections.
+ * Priority: H1 heading (level 1) > IDENTITY.md name field > SOUL.md heading > fallback.
+ */
+function extractDisplayName(sections, fallbackName) {
+    // Try the top-level H1 first (document title like "# Aria — AI Assistant")
+    const h1Section = sections.find(s => s.level === 1);
+    if (h1Section) {
+        const ht = headingText(h1Section);
+        if (ht && ht.length < 80)
+            return ht;
+    }
+    // Try IDENTITY.md — look for a name: field in content
+    const identitySection = sections.find(s => s.target === 'IDENTITY.md');
+    if (identitySection) {
+        const nameLine = identitySection.content
+            .split('\n')
+            .find(l => /\bname\b.*:/i.test(l) || /^name:/i.test(l.trim()));
+        if (nameLine) {
+            const val = nameLine.replace(/.*:\s*/, '').trim().replace(/[`*_]/g, '');
+            if (val && val.length < 50)
+                return val;
+        }
+        // Use heading if it's meaningful
+        const ht = headingText(identitySection);
+        if (ht && !['Identity', 'IDENTITY', 'Identity & Background'].includes(ht))
+            return ht;
+    }
+    // Try SOUL.md heading
+    const soulSection = sections.find(s => s.target === 'SOUL.md');
+    if (soulSection) {
+        const ht = headingText(soulSection);
+        if (ht && !['Persona', 'Soul', 'SOUL', 'Personality', 'Personality & Values'].includes(ht))
+            return ht;
+    }
+    return fallbackName || 'Imported Soul';
+}
+/**
+ * Extract keyword tags from all sections.
+ */
+function extractTags(sections) {
+    const tags = new Set();
+    const targets = sections.map(s => s.target).filter(t => t !== 'SKIP');
+    for (const t of targets) {
+        const base = t.replace('.md', '').toLowerCase();
+        if (base !== 'skip')
+            tags.add(base);
+    }
+    // Add a few keyword-based tags from SOUL.md content
+    const soulSection = sections.find(s => s.target === 'SOUL.md');
+    if (soulSection) {
+        const interestingWords = soulSection.content
+            .toLowerCase()
+            .match(/\b(creative|helpful|assistant|developer|coding|design|writer|analyst|researcher|friendly|professional)\b/g);
+        if (interestingWords) {
+            for (const w of interestingWords.slice(0, 3))
+                tags.add(w);
+        }
+    }
+    tags.add('imported');
+    return Array.from(tags).slice(0, 8);
+}
+/**
+ * Generate a soul.json object from classified sections.
+ */
+export function generateSoulJson(sections, opts = {}) {
+    const displayName = extractDisplayName(sections, opts.name);
+    const name = slugify(displayName);
+    // Description: first paragraph from SOUL.md, or IDENTITY.md
+    let description = '';
+    const soulSection = sections.find(s => s.target === 'SOUL.md');
+    if (soulSection?.content) {
+        description = extractFirstParagraph(soulSection.content);
+    }
+    if (!description) {
+        const identitySection = sections.find(s => s.target === 'IDENTITY.md');
+        if (identitySection?.content) {
+            description = extractFirstParagraph(identitySection.content);
+        }
+    }
+    if (!description)
+        description = 'Imported from external format';
+    return {
+        specVersion: '0.6',
+        name: name || 'imported-soul',
+        displayName,
+        version: '0.1.0',
+        description,
+        author: { name: opts.author || 'Unknown' },
+        category: 'imported',
+        tags: extractTags(sections),
+        type: 'persona',
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "clawsouls",
-  "version": "0.13.7",
+  "version": "0.14.0",
   "description": "CLI for ClawSouls — AI agent persona sharing platform",
   "main": "dist/index.js",
   "bin": {