noteconnection 1.7.0 → 1.8.0

package/dist/src/notemd/cli/index.js

@@ -0,0 +1,169 @@
+#!/usr/bin/env node
+"use strict";
+/**
+ * Notemd CLI Entry Point
+ *
+ * Usage: npx notemd <command> [options]
+ *   or:   node src/notemd/cli/index.ts <command> [options]
+ *
+ * Examples:
+ *   notemd process-file --path=notes/my_note.md
+ *   notemd search --query="machine learning"
+ *   notemd generate-diagram --path=notes/arch.md --intent=mermaid
+ *   notemd translate --path=notes/doc.md --language=zh
+ *   notemd manifest
+ *   notemd help
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const commands_1 = require("./commands");
+const NotemdService_1 = require("../NotemdService");
+const dispatcher_1 = require("./dispatcher");
+function createExecutionContext(workingDir) {
+    return {
+        workingDir,
+        getSetting: async (_key) => undefined,
+        callLlm: async (_prompt, _content) => { throw new Error('LLM not configured for CLI'); },
+        readFile: async (filePath) => {
+            const resolved = path.isAbsolute(filePath) ? filePath : path.resolve(workingDir, filePath);
+            return fs.promises.readFile(resolved, 'utf8');
+        },
+        writeFile: async (filePath, content) => {
+            const resolved = path.isAbsolute(filePath) ? filePath : path.resolve(workingDir, filePath);
+            await fs.promises.mkdir(path.dirname(resolved), { recursive: true });
+            await fs.promises.writeFile(resolved, content, 'utf8');
+        },
+        fileExists: async (filePath) => {
+            const resolved = path.isAbsolute(filePath) ? filePath : path.resolve(workingDir, filePath);
+            try {
+                await fs.promises.access(resolved);
+                return true;
+            }
+            catch {
+                return false;
+            }
+        },
+        mkdir: async (dirPath) => {
+            const resolved = path.isAbsolute(dirPath) ? dirPath : path.resolve(workingDir, dirPath);
+            await fs.promises.mkdir(resolved, { recursive: true });
+        }
+    };
+}
+function printHelp() {
+    console.log('Notemd CLI - LLM-powered note enhancement toolkit\n');
+    console.log('Usage: npx notemd <command> [options]\n');
+    console.log('Commands:');
+    const commands = (0, commands_1.listCommands)();
+    const maxLen = Math.max(...commands.map(c => c.name.length));
+    for (const cmd of commands) {
+        const pads = ' '.repeat(maxLen - cmd.name.length + 2);
+        console.log(`  ${cmd.name}${pads}${cmd.description}`);
+    }
+    console.log('\nRun "npx notemd <command> --help" for detailed options.');
+}
+async function main() {
+    const cliArgs = process.argv.slice(2);
+    if (cliArgs.length === 0 || cliArgs[0] === 'help' || cliArgs[0] === '--help' || cliArgs[0] === '-h') {
+        printHelp();
+        process.exit(0);
+    }
+    // Check for help on a specific command
+    if (cliArgs.includes('--help') || cliArgs.includes('-h')) {
+        const cmdName = cliArgs[0];
+        const cmd = (0, commands_1.findCommand)(cmdName);
+        if (cmd) {
+            console.log(`${cmd.name} — ${cmd.description}\n`);
+            console.log(`Operation: ${cmd.operationId}`);
+            console.log(`Automation: ${cmd.automationLevel} | Context: ${cmd.requiredContext} | Side Effects: ${cmd.sideEffectClass}\n`);
+            if (cmd.params.length > 0) {
+                console.log('Parameters:');
+                for (const p of cmd.params) {
+                    const req = p.required ? ' (required)' : '';
+                    const def = p.defaultValue ? ` [default: ${p.defaultValue}]` : '';
+                    console.log(`  --${p.name}${req}${def}`);
+                    console.log(`    ${p.description}`);
+                }
+            }
+            if (cmd.flags.length > 0) {
+                console.log('Flags:');
+                for (const f of cmd.flags) {
+                    console.log(`  --${f.name}`);
+                    console.log(`    ${f.description}`);
+                }
+            }
+        }
+        else {
+            console.log(`Unknown command: ${cmdName}`);
+        }
+        process.exit(0);
+    }
+    const workingDir = process.cwd();
+    const ctx = createExecutionContext(workingDir);
+    const service = new NotemdService_1.NotemdService();
+    // Load settings from notemd.toml if it exists, else use defaults
+    const settings = { providers: [], activeProvider: 'OpenAI', searchProvider: 'duckduckgo' };
+    const configPath = path.resolve(workingDir, 'notemd.toml');
+    try {
+        await fs.promises.access(configPath);
+        const configContent = await fs.promises.readFile(configPath, 'utf8');
+        // Parse TOML settings (basic: just use JSON format for CLI)
+        const config = JSON.parse(configContent);
+        Object.assign(settings, config);
+    }
+    catch {
+        // Use defaults
+    }
+    try {
+        const result = await (0, dispatcher_1.dispatchCommand)(cliArgs, ctx, service, settings);
+        if (result.success) {
+            console.log(JSON.stringify(result.data, null, 2));
+            process.exit(0);
+        }
+        else {
+            console.error(`Error: ${result.error}`);
+            process.exit(1);
+        }
+    }
+    catch (error) {
+        console.error('Fatal error:', error instanceof Error ? error.message : String(error));
+        process.exit(2);
+    }
+}
+main().catch((error) => {
+    console.error('Unhandled error:', error);
+    process.exit(2);
+});

package/dist/src/notemd/cli/parser.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseCliArgs = parseCliArgs;
+exports.resolveParam = resolveParam;
+exports.resolveBool = resolveBool;
+function parseCliArgs(args) {
+    const params = {};
+    const flags = new Set();
+    const positional = [];
+    let command = '';
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+        if (arg.startsWith('--')) {
+            const eqIdx = arg.indexOf('=');
+            if (eqIdx !== -1) {
+                const key = arg.slice(2, eqIdx);
+                const value = arg.slice(eqIdx + 1);
+                params[key] = value;
+            }
+            else {
+                const key = arg.slice(2);
+                // Check if next arg is a value
+                if (i + 1 < args.length && !args[i + 1].startsWith('-')) {
+                    params[key] = args[i + 1];
+                    i++;
+                }
+                else {
+                    flags.add(key);
+                }
+            }
+        }
+        else if (arg.startsWith('-')) {
+            const key = arg.slice(1);
+            if (i + 1 < args.length && !args[i + 1].startsWith('-')) {
+                params[key] = args[i + 1];
+                i++;
+            }
+            else {
+                flags.add(key);
+            }
+        }
+        else if (!command) {
+            command = arg;
+        }
+        else {
+            positional.push(arg);
+        }
+    }
+    return { command, params, flags, positional };
+}
+function resolveParam(params, keys, fallback) {
+    for (const key of keys) {
+        if (params[key] !== undefined)
+            return params[key];
+    }
+    return fallback;
+}
+function resolveBool(params, flags, keys) {
+    for (const key of keys) {
+        if (flags.has(key))
+            return true;
+        if (params[key] !== undefined) {
+            const v = params[key].toLowerCase();
+            return v === 'true' || v === '1' || v === 'yes';
+        }
+    }
+    return false;
+}

package/dist/src/notemd/cli/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/src/notemd/constants.js

@@ -77,4 +77,47 @@ exports.DEFAULT_SETTINGS = {
     disableAutoTranslation: false,
     enableGlobalCustomPrompts: false,
     customPrompts: {},
+    // ── Search (obsidian-notemd v1.8.4) ──
+    tavilyApiKey: '',
+    searchProvider: 'tavily',
+    ddgMaxResults: 5,
+    ddgFetchTimeout: 10000,
+    maxResearchContentTokens: 32000,
+    tavilyMaxResults: 5,
+    tavilySearchDepth: 'basic',
+    // ── Diagram pipeline (obsidian-notemd v1.8.4) ──
+    enableExperimentalDiagramPipeline: false,
+    experimentalDiagramCompatibilityMode: 'best-fit',
+    preferredDiagramIntent: undefined,
+    useCustomSummarizeToMermaidSuffix: false,
+    summarizeToMermaidCustomSuffix: '',
+    useCustomSummarizeToMermaidSavePath: false,
+    summarizeToMermaidSavePath: '',
+    translateSummarizeToMermaidOutput: false,
+    // ── Mermaid error detection (obsidian-notemd v1.8.4) ──
+    enableMermaidErrorDetection: false,
+    moveMermaidErrorFiles: false,
+    mermaidErrorFolderPath: '',
+    // ── Extract original text (obsidian-notemd v1.8.4) ──
+    extractOriginalTextMergedMode: false,
+    extractOriginalTextUseCustomOutput: false,
+    extractOriginalTextCustomPath: '',
+    extractOriginalTextCustomSuffix: '',
+    translateExtractOriginalTextOutput: false,
+    // ── Duplicate detection (obsidian-notemd v1.8.4) ──
+    duplicateCheckScopeMode: 'vault',
+    duplicateCheckScopePaths: '',
+    // ── Add links post-processing (obsidian-notemd v1.8.4) ──
+    removeCodeFencesOnAddLinks: false,
+    // ── Workflow (obsidian-notemd v1.8.4) ──
+    extractQuestions: '',
+    customWorkflowErrorStrategy: 'stop_on_error',
+    customWorkflowButtonsDsl: '',
+    // ── Developer diagnostics (obsidian-notemd v1.8.4) ──
+    enableDeveloperMode: false,
+    developerDiagnosticCallMode: 'single',
+    developerDiagnosticStabilityRuns: 5,
+    developerDiagnosticTimeoutMs: 10000,
+    enableApiErrorDebugMode: false,
+    enableStableApiCall: false,
 };

package/dist/src/notemd/diagram/diagramGenerationService.js

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateDiagramArtifact = generateDiagramArtifact;
+const planner_1 = require("./planner");
+const diagramSpecPrompt_1 = require("./prompts/diagramSpecPrompt");
+const diagramSpec_1 = require("./diagramSpec");
+const diagramSpecResponseParser_1 = require("./diagramSpecResponseParser");
+function mergeSpecDefaults(spec, plan) {
+    const resolvedIntent = plan.legacyCompatibilityMode ? plan.intent : spec.intent;
+    const normalizedLayoutHints = { ...(spec.layoutHints ?? {}) };
+    if (resolvedIntent !== 'dataChart')
+        delete normalizedLayoutHints.chartType;
+    else if (normalizedLayoutHints.chartType === undefined && plan.preferredChartType) {
+        normalizedLayoutHints.chartType = plan.preferredChartType;
+    }
+    return {
+        ...spec,
+        intent: resolvedIntent,
+        title: spec.title?.trim() || 'Generated Diagram',
+        nodes: (spec.nodes ?? []).map(node => ({ ...node, label: node.label?.trim() || node.id || 'Untitled' })),
+        edges: (spec.edges ?? []).map(edge => ({ ...edge, label: edge.label?.trim() || undefined })),
+        sections: spec.sections ?? [],
+        callouts: spec.callouts ?? [],
+        dataSeries: spec.dataSeries ?? [],
+        layoutHints: Object.keys(normalizedLayoutHints).length > 0 ? normalizedLayoutHints : undefined,
+        evidenceRefs: spec.evidenceRefs ?? []
+    };
+}
+function specToMermaid(spec) {
+    const { intent, nodes, edges } = spec;
+    const nodeLines = nodes.map(n => `    ${n.id}[${n.label || n.id}]`);
+    const edgeLines = (edges ?? []).map(e => `    ${e.from} --> ${e.to}${e.label ? `: ${e.label}` : ''}`);
+    switch (intent) {
+        case 'mindmap': return `mindmap\n  ${spec.title}\n${nodes.map(n => `    ${n.label || n.id}`).join('\n')}`;
+        case 'sequence': return `sequenceDiagram\n${nodes.map(n => `    participant ${n.id} as ${n.label}`).join('\n')}\n${(edges ?? []).map(e => `    ${e.from}->>${e.to}: ${e.label || ''}`).join('\n')}`;
+        case 'classDiagram': return `classDiagram\n${nodes.map(n => `    class ${n.id} {\n      ${n.label}\n    }`).join('\n')}`;
+        case 'erDiagram': return `erDiagram\n${nodes.map(n => `    ${n.id} {\n      string label "${n.label}"\n    }`).join('\n')}\n${(edges ?? []).map(e => `    ${e.from} ||--o{ ${e.to} : "${e.label || ''}"`).join('\n')}`;
+        case 'stateDiagram': return `stateDiagram-v2\n${nodes.map(n => `    state "${n.label}" as ${n.id}`).join('\n')}\n${(edges ?? []).map(e => `    ${e.from} --> ${e.to}: ${e.label || ''}`).join('\n')}`;
+        default: return `graph TD\n${nodeLines.join('\n')}\n${edgeLines.join('\n')}`;
+    }
+}
+async function generateDiagramArtifact(markdown, options) {
+    const plan = (0, planner_1.buildDiagramPlan)(markdown, {
+        compatibilityMode: options.compatibilityMode,
+        requestedIntent: options.requestedIntent
+    });
+    const prompt = (0, diagramSpecPrompt_1.buildDiagramSpecPrompt)({
+        preferredIntent: plan.intent,
+        requiredIntent: options.requestedIntent,
+        preferredChartType: plan.preferredChartType,
+        targetLanguage: options.targetLanguage
+    });
+    let rawResponse = await options.llmInvoker(prompt, markdown);
+    let parsedSpec = (0, diagramSpecResponseParser_1.parseDiagramSpecResponse)(rawResponse);
+    let spec = mergeSpecDefaults(parsedSpec, plan);
+    (0, diagramSpec_1.assertValidDiagramSpec)(spec);
+    // Retry if intent mismatch
+    if (options.requestedIntent && spec.intent !== options.requestedIntent) {
+        const retryPrompt = (0, diagramSpecPrompt_1.buildDiagramSpecPrompt)({
+            preferredIntent: plan.intent,
+            requiredIntent: options.requestedIntent,
+            preferredChartType: plan.preferredChartType,
+            targetLanguage: options.targetLanguage
+        }) + `\n\nCRITICAL: Your previous response used intent "${spec.intent}" but the required intent is "${options.requestedIntent}". Regenerate with the correct intent.`;
+        rawResponse = await options.llmInvoker(retryPrompt, markdown);
+        parsedSpec = (0, diagramSpecResponseParser_1.parseDiagramSpecResponse)(rawResponse);
+        spec = mergeSpecDefaults(parsedSpec, plan);
+        (0, diagramSpec_1.assertValidDiagramSpec)(spec);
+    }
+    const mermaidContent = specToMermaid(spec);
+    return {
+        plan,
+        spec,
+        mermaidContent,
+        artifactTarget: plan.renderTarget,
+        renderError: undefined
+    };
+}

package/dist/src/notemd/diagram/diagramSpec.js

@@ -0,0 +1,79 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateDiagramSpec = validateDiagramSpec;
+exports.assertValidDiagramSpec = assertValidDiagramSpec;
+const types_1 = require("./types");
+const types_2 = require("../types");
+function collectNodeIds(nodes, ids, errors) {
+    nodes.forEach(node => {
+        const id = node.id?.trim();
+        if (!id) {
+            errors.push('Diagram node is missing an id.');
+            return;
+        }
+        if (ids.has(id)) {
+            errors.push(`Diagram node id "${id}" is duplicated.`);
+        }
+        else {
+            ids.add(id);
+        }
+        if (!node.label?.trim()) {
+            errors.push(`Diagram node "${id}" is missing a label.`);
+        }
+        if (node.children?.length) {
+            collectNodeIds(node.children, ids, errors);
+        }
+    });
+}
+function validateDataSeries(dataSeries, errors) {
+    if (!dataSeries || dataSeries.length === 0) {
+        errors.push('Diagram intent "dataChart" requires at least one data series.');
+        return;
+    }
+    dataSeries.forEach(series => {
+        if (!series.id?.trim())
+            errors.push('Chart data series is missing an id.');
+        if (!series.label?.trim())
+            errors.push(`Chart data series "${series.id || 'unknown'}" is missing a label.`);
+        if (!series.points?.length) {
+            errors.push(`Chart data series "${series.id || 'unknown'}" is missing points.`);
+            return;
+        }
+        series.points.forEach((point, index) => {
+            if (point.x === '' || point.x === null || point.x === undefined) {
+                errors.push(`Chart data series "${series.id || 'unknown'}" point ${index + 1} is missing x.`);
+            }
+            if (typeof point.y !== 'number' || Number.isNaN(point.y)) {
+                errors.push(`Chart data series "${series.id || 'unknown'}" point ${index + 1} is missing a numeric y.`);
+            }
+        });
+    });
+}
+function validateDiagramSpec(spec) {
+    const errors = [];
+    if (!(0, types_1.isSupportedDiagramIntent)(spec.intent)) {
+        errors.push(`Diagram spec uses unsupported intent "${String(spec.intent)}". Supported: ${types_1.SUPPORTED_DIAGRAM_INTENTS.join(', ')}.`);
+    }
+    if (!spec.title?.trim())
+        errors.push('Diagram spec title is required.');
+    const nodeIds = new Set();
+    collectNodeIds(spec.nodes ?? [], nodeIds, errors);
+    if (spec.intent !== 'dataChart' && nodeIds.size === 0) {
+        errors.push(`Diagram intent "${spec.intent}" requires at least one node.`);
+    }
+    (spec.edges ?? []).forEach((edge, index) => {
+        if (!nodeIds.has(edge.from))
+            errors.push(`Diagram edge ${index + 1} references missing source node "${edge.from}".`);
+        if (!nodeIds.has(edge.to))
+            errors.push(`Diagram edge ${index + 1} references missing target node "${edge.to}".`);
+    });
+    if (spec.intent === 'dataChart')
+        validateDataSeries(spec.dataSeries, errors);
+    return { valid: errors.length === 0, errors };
+}
+function assertValidDiagramSpec(spec) {
+    const result = validateDiagramSpec(spec);
+    if (!result.valid)
+        throw new types_2.ValidationError(result.errors.join(' '), 'INVALID_INPUT');
+    return spec;
+}

package/dist/src/notemd/diagram/diagramSpecResponseParser.js

@@ -0,0 +1,131 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseDiagramSpecResponse = parseDiagramSpecResponse;
+function stripCodeFence(raw) {
+    const trimmed = raw.trim();
+    const fencedMatch = trimmed.match(/^```(?:json)?\s*([\s\S]*?)\s*```$/i);
+    return fencedMatch ? fencedMatch[1].trim() : trimmed;
+}
+function extractJsonObject(raw) {
+    const stripped = stripCodeFence(raw);
+    const start = stripped.indexOf('{');
+    const end = stripped.lastIndexOf('}');
+    if (start === -1 || end === -1 || end < start) {
+        throw new Error('Unable to parse DiagramSpec: no JSON object found in LLM response.');
+    }
+    return stripped.slice(start, end + 1);
+}
+function readTrimmedString(value) {
+    if (typeof value !== 'string')
+        return undefined;
+    const trimmed = value.trim();
+    return trimmed.length > 0 ? trimmed : undefined;
+}
+function readNumericValue(value) {
+    if (typeof value === 'number' && !Number.isNaN(value))
+        return value;
+    if (typeof value !== 'string')
+        return undefined;
+    const trimmed = value.trim();
+    if (!/^-?\d[\d,]*(\.\d+)?%?$/.test(trimmed))
+        return undefined;
+    const normalized = trimmed.replace(/,/g, '').replace(/%$/, '');
+    const parsed = Number(normalized);
+    return Number.isNaN(parsed) ? undefined : parsed;
+}
+function slugify(value) {
+    return value.toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-+|-+$/g, '');
+}
+function normalizePoint(point, fallbackSeriesLabel) {
+    if (Array.isArray(point) && point.length >= 2) {
+        const x = point[0];
+        const y = readNumericValue(point[1]);
+        if ((typeof x === 'string' || typeof x === 'number') && y !== undefined) {
+            return { x: typeof x === 'string' ? x.trim() : x, y, series: fallbackSeriesLabel };
+        }
+        return null;
+    }
+    if (!point || typeof point !== 'object')
+        return null;
+    const pr = point;
+    const explicitX = pr.x;
+    const fallbackX = pr.label ?? pr.name ?? pr.category ?? pr.item ?? pr.date ?? pr.key ?? pr.id;
+    const xc = explicitX ?? fallbackX;
+    const x = typeof xc === 'number' ? xc : readTrimmedString(xc);
+    let y = readNumericValue(pr.y);
+    if (y === undefined)
+        y = readNumericValue(pr.value ?? pr.amount ?? pr.count ?? pr.total ?? pr.metric);
+    if ((x === undefined || x === '') && y === undefined) {
+        const entries = Object.entries(pr);
+        if (entries.length === 1) {
+            const [key, value] = entries[0];
+            const pv = readNumericValue(value);
+            if (pv !== undefined)
+                return { x: key, y: pv, series: fallbackSeriesLabel };
+        }
+    }
+    if ((typeof x !== 'string' && typeof x !== 'number') || y === undefined)
+        return null;
+    return { x, y, series: readTrimmedString(pr.series) ?? fallbackSeriesLabel };
+}
+function normalizeSeriesEntries(rawDataSeries) {
+    if (Array.isArray(rawDataSeries))
+        return rawDataSeries;
+    if (!rawDataSeries || typeof rawDataSeries !== 'object')
+        return [];
+    return Object.entries(rawDataSeries).map(([key, value]) => {
+        if (Array.isArray(value))
+            return { id: key, label: key, points: value };
+        if (value && typeof value === 'object') {
+            return { ...value, id: value.id ?? key, label: value.label ?? value.name ?? key };
+        }
+        return { id: key, label: key, points: [] };
+    });
+}
+function normalizeDataSeries(rawDataSeries, title) {
+    const seriesEntries = normalizeSeriesEntries(rawDataSeries);
+    return seriesEntries.map((series, index) => {
+        const labelFallback = title.trim().length > 0
+            ? (seriesEntries.length === 1 ? title.trim() : `${title.trim()} ${index + 1}`)
+            : `Series ${index + 1}`;
+        const label = readTrimmedString(series?.label) ?? readTrimmedString(series?.name) ?? readTrimmedString(series?.title) ?? readTrimmedString(series?.series) ?? labelFallback;
+        const slugId = slugify(label);
+        const id = readTrimmedString(series?.id) ?? readTrimmedString(series?.key) ?? (slugId || `series-${index + 1}`);
+        const rawPoints = Array.isArray(series?.points) ? series.points : Array.isArray(series?.values) ? series.values : Array.isArray(series?.data) ? series.data : Array.isArray(series?.items) ? series.items : [];
+        const points = rawPoints.map((p) => normalizePoint(p, label)).filter((p) => p !== null);
+        return { id, label, points };
+    });
+}
+function normalizeSpec(candidate) {
+    const payload = candidate?.diagramSpec ?? candidate;
+    const title = typeof payload.title === 'string' ? payload.title : '';
+    return {
+        intent: payload.intent,
+        title,
+        summary: typeof payload.summary === 'string' ? payload.summary : undefined,
+        nodes: Array.isArray(payload.nodes) ? payload.nodes : [],
+        edges: Array.isArray(payload.edges) ? payload.edges.map((e) => ({
+            from: e.from ?? e.source ?? e.sourceId ?? e.start,
+            to: e.to ?? e.target ?? e.targetId ?? e.end,
+            label: e.label,
+            relation: e.relation,
+        })) : [],
+        sections: Array.isArray(payload.sections) ? payload.sections : [],
+        callouts: Array.isArray(payload.callouts) ? payload.callouts : [],
+        dataSeries: normalizeDataSeries(payload.dataSeries, title),
+        layoutHints: payload.layoutHints && typeof payload.layoutHints === 'object' ? payload.layoutHints : undefined,
+        sourceLanguage: typeof payload.sourceLanguage === 'string' ? payload.sourceLanguage : undefined,
+        outputLanguage: typeof payload.outputLanguage === 'string' ? payload.outputLanguage : undefined,
+        evidenceRefs: Array.isArray(payload.evidenceRefs) ? payload.evidenceRefs : []
+    };
+}
+function parseDiagramSpecResponse(raw) {
+    try {
+        const jsonObject = extractJsonObject(raw);
+        return normalizeSpec(JSON.parse(jsonObject));
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw new Error(`Unable to parse DiagramSpec response: ${message}`);
+    }
+}

package/dist/src/notemd/diagram/intent.js

@@ -0,0 +1,95 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.inferDiagramIntent = inferDiagramIntent;
+function countMatches(content, patterns) {
+    return patterns.reduce((count, pattern) => count + (content.match(pattern)?.length ?? 0), 0);
+}
+function scoreResult(intent, score, reasons) {
+    return { intent, confidence: Math.min(0.99, Math.max(0.2, score)), reasons };
+}
+function inferDiagramIntent(markdown) {
+    const normalized = markdown.toLowerCase();
+    const trimmed = normalized.trim();
+    if (!trimmed) {
+        return scoreResult('mindmap', 0.2, ['empty content defaults to hierarchical summary']);
+    }
+    const chartReasons = [];
+    const hasMarkdownTable = /\|.+\|/.test(normalized) && /\|\s*-+\s*\|/.test(normalized);
+    const numericCells = (normalized.match(/\|\s*\d+(?:\.\d+)?\s*\|/g) ?? []).length;
+    const percentValues = (normalized.match(/\b\d+(?:\.\d+)?%/g) ?? []).length;
+    const numericTokens = (normalized.match(/\b\d+(?:\.\d+)?\b/g) ?? []).length;
+    const chartKeywords = countMatches(normalized, [
+        /\bmetric(s)?\b/g, /\btrend(s)?\b/g, /\bweekly\b/g, /\bmonthly\b/g,
+        /\bgrowth\b/g, /\bsignup(s)?\b/g, /\brevenue\b/g, /\bcount\b/g
+    ]);
+    const shareKeywords = countMatches(normalized, [
+        /\bshare\b/g, /\bmix\b/g, /\bbreakdown\b/g, /\bdistribution\b/g,
+        /\bcomposition\b/g, /\bportion\b/g
+    ]);
+    const comparisonKeywords = countMatches(normalized, [
+        /\bvs\.?\b/g, /\bversus\b/g, /\bcompare\b/g, /\bcomparison\b/g,
+        /\blatency\b/g, /\bthroughput\b/g, /\bcorrelation\b/g
+    ]);
+    const rankingKeywords = countMatches(normalized, [
+        /\btop\b/g, /\brank(?:ed|ing)?\b/g, /\bissue(?:s)?\b/g,
+        /\bleaderboard\b/g, /\bhighest\b/g, /\blowest\b/g
+    ]);
+    if (hasMarkdownTable)
+        chartReasons.push('markdown table detected');
+    if (numericCells >= 2)
+        chartReasons.push('numeric table values detected');
+    if (chartKeywords > 0)
+        chartReasons.push('metric-oriented keywords detected');
+    if (shareKeywords > 0)
+        chartReasons.push('part-to-whole keywords detected');
+    if (percentValues >= 2)
+        chartReasons.push('percentage values detected');
+    if (comparisonKeywords > 0)
+        chartReasons.push('comparison vocabulary detected');
+    if (rankingKeywords > 0 && numericTokens >= 4)
+        chartReasons.push('ranked numeric items detected');
+    if (chartReasons.length >= 2)
+        return scoreResult('dataChart', 0.88, chartReasons);
+    const sequenceKeywords = countMatches(normalized, [
+        /\brequest\b/g, /\bresponse\b/g, /\bsend(s|ing)?\b/g, /\breturn(s|ed|ing)?\b/g,
+        /\bclient\b/g, /\bserver\b/g, /\bgateway\b/g, /\bservice\b/g
+    ]);
+    const sequenceReasons = [];
+    if (sequenceKeywords >= 4)
+        sequenceReasons.push('request-response vocabulary detected');
+    if (/->|=>/.test(normalized))
+        sequenceReasons.push('directional interaction markers detected');
+    if (sequenceReasons.length > 0)
+        return scoreResult('sequence', 0.82, sequenceReasons);
+    const erKeywords = countMatches(normalized, [
+        /\bprimary key\b/g, /\bforeign key\b/g, /\bentity\b/g, /\btable\b/g,
+        /\bcolumn\b/g, /\bschema\b/g
+    ]);
+    if (erKeywords >= 2)
+        return scoreResult('erDiagram', 0.8, ['data-model vocabulary detected']);
+    const stateKeywords = countMatches(normalized, [
+        /\bstate\b/g, /\btransition\b/g, /\bpending\b/g, /\brunning\b/g,
+        /\bcompleted\b/g, /\bfailed\b/g
+    ]);
+    if (stateKeywords >= 3)
+        return scoreResult('stateDiagram', 0.76, ['state-transition vocabulary detected']);
+    const canvasKeywords = countMatches(normalized, [
+        /\bconcept map\b/g, /\bknowledge graph\b/g, /\bspatial\b/g,
+        /\bcluster\b/g, /\bmap the relationships\b/g
+    ]);
+    if (canvasKeywords >= 1)
+        return scoreResult('canvasMap', 0.72, ['spatial knowledge mapping vocabulary detected']);
+    const flowchartReasons = [];
+    const numberedSteps = (normalized.match(/^\s*\d+\./gm) ?? []).length;
+    if (numberedSteps >= 2)
+        flowchartReasons.push('numbered steps detected');
+    const flowKeywords = countMatches(normalized, [
+        /\bif\b/g, /\bthen\b/g, /\belse\b/g, /\bstep\b/g, /\bprocess\b/g,
+        /\bworkflow\b/g, /\bvalidate\b/g, /\bcontinue\b/g, /\bstop\b/g
+    ]);
+    if (flowKeywords >= 2)
+        flowchartReasons.push('workflow/process vocabulary detected');
+    if (flowchartReasons.length > 0)
+        return scoreResult('flowchart', 0.74, flowchartReasons);
+    return scoreResult('mindmap', 0.55, ['defaulted to hierarchical summary structure']);
+}