noteconnection 1.7.0 → 1.8.0

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

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildDiagramPlan = buildDiagramPlan;
+const intent_1 = require("./intent");
+function resolvePreferredRenderTarget(intent) {
+    switch (intent) {
+        case 'canvasMap': return 'json-canvas';
+        case 'dataChart': return 'vega-lite';
+        default: return 'mermaid';
+    }
+}
+function resolveMermaidDiagramType(intent) {
+    switch (intent) {
+        case 'mindmap': return 'mindmap';
+        case 'flowchart': return 'flowchart';
+        case 'sequence': return 'sequenceDiagram';
+        case 'classDiagram': return 'classDiagram';
+        case 'erDiagram': return 'erDiagram';
+        case 'stateDiagram': return 'stateDiagram-v2';
+        default: return null;
+    }
+}
+function resolveFallbackTargets(compatibilityMode, preferredTarget, preferredMermaidType) {
+    if (compatibilityMode === 'legacy-mermaid')
+        return [];
+    const fallbackTargets = [];
+    if (preferredTarget !== 'mermaid' && preferredMermaidType)
+        fallbackTargets.push('mermaid');
+    if (preferredTarget !== 'html')
+        fallbackTargets.push('html');
+    return fallbackTargets;
+}
+function inferPreferredChartType(markdown, intent) {
+    if (intent !== 'dataChart')
+        return undefined;
+    const normalized = markdown.toLowerCase();
+    if (/\bvs\.?\b|\bversus\b|\bcorrelation\b|\bscatter\b|\bthroughput\b|\blatency\b/.test(normalized))
+        return 'scatter';
+    if (/%/.test(normalized) || /\bshare\b|\bmix\b|\bbreakdown\b|\bcomposition\b|\bportion\b|\bdistribution\b/.test(normalized))
+        return 'pie';
+    if (/\btop\b|\brank(?:ed|ing)?\b|\bleaderboard\b|\bissue(?:s)?\b/.test(normalized))
+        return 'table';
+    if (/\bday\b|\bdaily\b|\bweek\b|\bweekly\b|\bmonth\b|\bmonthly\b|\bquarter\b|\bquarterly\b|\byear\b|\byearly\b|\btrend\b|\bover time\b/.test(normalized))
+        return 'line';
+    return 'bar';
+}
+function buildIntentResult(markdown, requestedIntent) {
+    if (!requestedIntent)
+        return (0, intent_1.inferDiagramIntent)(markdown);
+    return { intent: requestedIntent, confidence: 0.95, reasons: ['explicit intent requested'] };
+}
+function buildDiagramPlan(markdown, options = {}) {
+    const compatibilityMode = options.compatibilityMode ?? 'best-fit';
+    const inferred = buildIntentResult(markdown, options.requestedIntent);
+    const preferredTarget = resolvePreferredRenderTarget(inferred.intent);
+    const preferredMermaidType = resolveMermaidDiagramType(inferred.intent);
+    const preferredChartType = inferPreferredChartType(markdown, inferred.intent);
+    const fallbackTargets = resolveFallbackTargets(compatibilityMode, preferredTarget, preferredMermaidType);
+    if (compatibilityMode === 'legacy-mermaid') {
+        return {
+            intent: inferred.intent, confidence: inferred.confidence, reasons: inferred.reasons,
+            renderTarget: 'mermaid', fallbackTargets, preferredChartType,
+            mermaidDiagramType: preferredMermaidType ?? 'mindmap', legacyCompatibilityMode: true
+        };
+    }
+    return {
+        intent: inferred.intent, confidence: inferred.confidence, reasons: inferred.reasons,
+        renderTarget: preferredTarget, fallbackTargets, preferredChartType,
+        mermaidDiagramType: preferredMermaidType, legacyCompatibilityMode: false
+    };
+}

package/dist/src/notemd/diagram/prompts/diagramSpecPrompt.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildDiagramSpecPrompt = buildDiagramSpecPrompt;
+function buildDiagramSpecPrompt(options = {}) {
+    const supportedChartTypes = 'bar, line, pie, scatter, table';
+    const preferredIntentLine = options.requiredIntent
+        ? `REQUIRED diagram intent: ${options.requiredIntent}. You MUST use this exact intent. Do not choose any other intent under any circumstances.`
+        : options.preferredIntent
+            ? `Preferred diagram intent: ${options.preferredIntent}. Follow it when the source content supports it.`
+            : 'Preferred diagram intent: choose the most suitable intent from the supported list.';
+    const preferredChartTypeLine = options.preferredIntent === 'dataChart' && options.preferredChartType
+        ? `Preferred chart template: ${options.preferredChartType}. Use it when the extracted data supports it.`
+        : '';
+    const targetLanguageLine = options.targetLanguage
+        ? `Write all human-readable labels in ${options.targetLanguage}.`
+        : 'Write all human-readable labels in the same language as the source unless the caller specifies a target language.';
+    return `You are a diagram planning assistant. Analyze the source note and return a structured DiagramSpec JSON object.
+
+Output rules:
+- Return JSON only. Do not wrap the JSON in markdown code fences.
+- Do not output Mermaid, Canvas, Vega-Lite, PlantUML, or any other renderer syntax.
+- Do not output explanations outside the DiagramSpec JSON payload.
+- Do not invent numeric data. If the source lacks reliable numeric values, choose a non-dataChart intent and leave dataSeries empty.
+
+Supported intents: mindmap, flowchart, sequence, classDiagram, erDiagram, stateDiagram, canvasMap, dataChart
+
+${preferredIntentLine}
+${preferredChartTypeLine}
+${targetLanguageLine}
+
+Required DiagramSpec fields:
+- intent: one of the supported intents
+- title: a concise descriptive title
+- summary: a short description of the diagram
+- nodes: array of {id, label, kind?, children?}
+- edges: array of {from, to, label?, relation?}
+- sections: array of {id, label, summary?}
+- callouts: array of {label, detail}
+- dataSeries: array of {id, label, points: [{x, y, series?}]}
+- layoutHints: optional {chartType?}
+- sourceLanguage, outputLanguage: optional language codes`;
+}

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

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SUPPORTED_DIAGRAM_INTENTS = void 0;
+exports.isSupportedDiagramIntent = isSupportedDiagramIntent;
+exports.SUPPORTED_DIAGRAM_INTENTS = [
+    'mindmap',
+    'flowchart',
+    'sequence',
+    'classDiagram',
+    'erDiagram',
+    'stateDiagram',
+    'canvasMap',
+    'dataChart'
+];
+function isSupportedDiagramIntent(value) {
+    return typeof value === 'string'
+        && exports.SUPPORTED_DIAGRAM_INTENTS.includes(value);
+}

package/dist/src/notemd/index.js

@@ -14,6 +14,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.isSupportedDiagramIntent = exports.SUPPORTED_DIAGRAM_INTENTS = exports.TavilyProvider = exports.DuckDuckGoProvider = void 0;
 __exportStar(require("./types"), exports);
 __exportStar(require("./constants"), exports);
 __exportStar(require("./LlmProviderDefinitions"), exports);
@@ -27,3 +28,28 @@ __exportStar(require("./MermaidProcessor"), exports);
 __exportStar(require("./FormulaFixer"), exports);
 __exportStar(require("./DuplicateDetector"), exports);
 __exportStar(require("./NotemdService"), exports);
+__exportStar(require("./operations/types"), exports);
+__exportStar(require("./operations/registry"), exports);
+__exportStar(require("./operations/capabilityManifest"), exports);
+__exportStar(require("./operations/cliContracts"), exports);
+__exportStar(require("./operations/configProfileCommands"), exports);
+__exportStar(require("./providerProfiles"), exports);
+__exportStar(require("./providerDiagnostics"), exports);
+__exportStar(require("./search/SearchManager"), exports);
+var DuckDuckGoProvider_1 = require("./search/DuckDuckGoProvider");
+Object.defineProperty(exports, "DuckDuckGoProvider", { enumerable: true, get: function () { return DuckDuckGoProvider_1.DuckDuckGoProvider; } });
+var TavilyProvider_1 = require("./search/TavilyProvider");
+Object.defineProperty(exports, "TavilyProvider", { enumerable: true, get: function () { return TavilyProvider_1.TavilyProvider; } });
+var types_1 = require("./diagram/types");
+Object.defineProperty(exports, "SUPPORTED_DIAGRAM_INTENTS", { enumerable: true, get: function () { return types_1.SUPPORTED_DIAGRAM_INTENTS; } });
+Object.defineProperty(exports, "isSupportedDiagramIntent", { enumerable: true, get: function () { return types_1.isSupportedDiagramIntent; } });
+__exportStar(require("./diagram/intent"), exports);
+__exportStar(require("./diagram/planner"), exports);
+__exportStar(require("./diagram/diagramSpec"), exports);
+__exportStar(require("./diagram/diagramSpecResponseParser"), exports);
+__exportStar(require("./diagram/diagramGenerationService"), exports);
+__exportStar(require("./diagram/prompts/diagramSpecPrompt"), exports);
+__exportStar(require("./cli/parser"), exports);
+__exportStar(require("./cli/types"), exports);
+__exportStar(require("./cli/commands"), exports);
+__exportStar(require("./cli/dispatcher"), exports);

package/dist/src/notemd/operations/capabilityManifest.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildCliCapabilityManifest = buildCliCapabilityManifest;
+const registry_1 = require("./registry");
+function buildCliCapabilityManifest(pluginId = 'notemd') {
+    return {
+        version: 1,
+        commands: (0, registry_1.listOperationDefinitions)().flatMap(definition => definition.commandBindings
+            .filter(binding => binding.includeInCapabilityManifest !== false)
+            .map(binding => ({
+            id: `${pluginId}:${binding.commandId}`,
+            localCommandId: binding.commandId,
+            operationId: definition.id,
+            operationVersion: definition.version,
+            automationLevel: binding.automationLevel,
+            requiredContext: binding.requiredContext,
+            sideEffectClass: binding.sideEffectClass,
+            surfaces: [...binding.surfaces],
+            mappingKind: binding.mappingKind,
+            defaultInput: binding.defaultInput ? { ...binding.defaultInput } : undefined
+        })))
+    };
+}

package/dist/src/notemd/operations/cliContracts.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildCliInvocationContract = buildCliInvocationContract;
+const registry_1 = require("./registry");
+function buildCliInvocationContract() {
+    return {
+        version: 1,
+        operations: (0, registry_1.listOperationDefinitions)()
+            .filter(definition => definition.inputSchema && definition.resultSchema)
+            .map(definition => ({
+            operationId: definition.id,
+            operationVersion: definition.version,
+            inputSchema: definition.inputSchema,
+            resultSchema: definition.resultSchema
+        }))
+    };
+}

package/dist/src/notemd/operations/configProfileCommands.js

@@ -0,0 +1,85 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MissingProviderProfileImportFileError = exports.CLI_INVOCATION_CONTRACT_FILE_NAME = exports.CLI_CAPABILITY_MANIFEST_FILE_NAME = exports.PROVIDER_PROFILE_FILE_NAME = void 0;
+exports.buildPluginConfigDir = buildPluginConfigDir;
+exports.buildPluginConfigFilePath = buildPluginConfigFilePath;
+exports.executeExportProviderProfilesCommand = executeExportProviderProfilesCommand;
+exports.executeImportProviderProfilesCommand = executeImportProviderProfilesCommand;
+exports.executeExportCliCapabilityManifestCommand = executeExportCliCapabilityManifestCommand;
+exports.executeExportCliInvocationContractCommand = executeExportCliInvocationContractCommand;
+const cliContracts_1 = require("./cliContracts");
+const capabilityManifest_1 = require("./capabilityManifest");
+const providerProfiles_1 = require("../providerProfiles");
+exports.PROVIDER_PROFILE_FILE_NAME = 'notemd-providers.json';
+exports.CLI_CAPABILITY_MANIFEST_FILE_NAME = 'notemd-cli-capabilities.json';
+exports.CLI_INVOCATION_CONTRACT_FILE_NAME = 'notemd-cli-contract.json';
+class MissingProviderProfileImportFileError extends Error {
+    constructor(inputPath) {
+        super(`Provider profile import file not found: ${inputPath}`);
+        this.inputPath = inputPath;
+        this.name = 'MissingProviderProfileImportFileError';
+    }
+}
+exports.MissingProviderProfileImportFileError = MissingProviderProfileImportFileError;
+function buildPluginConfigDir(configDir, pluginId) {
+    return `${configDir}/plugins/${pluginId}`;
+}
+function buildPluginConfigFilePath(configDir, pluginId, fileName) {
+    return `${buildPluginConfigDir(configDir, pluginId)}/${fileName}`;
+}
+async function ensurePluginConfigDir(host, pluginId) {
+    const pluginConfigDir = buildPluginConfigDir(host.configDir, pluginId);
+    if (!(await host.exists(pluginConfigDir))) {
+        await host.mkdir(pluginConfigDir);
+    }
+    return pluginConfigDir;
+}
+async function writePluginConfigJsonFile(host, pluginId, fileName, payload) {
+    await ensurePluginConfigDir(host, pluginId);
+    const outputPath = buildPluginConfigFilePath(host.configDir, pluginId, fileName);
+    await host.write(outputPath, JSON.stringify(payload, null, 2));
+    return outputPath;
+}
+function resolveImportedActiveProvider(importedProviders, activeProvider, defaultActiveProvider) {
+    const providerNames = new Set(importedProviders.map(provider => provider.name));
+    if (providerNames.has(activeProvider)) {
+        return { activeProvider, activeProviderReset: false };
+    }
+    if (providerNames.has(defaultActiveProvider)) {
+        return { activeProvider: defaultActiveProvider, activeProviderReset: true };
+    }
+    if (importedProviders.length > 0) {
+        return { activeProvider: importedProviders[0].name, activeProviderReset: true };
+    }
+    return { activeProvider: defaultActiveProvider, activeProviderReset: true };
+}
+async function executeExportProviderProfilesCommand(params) {
+    const profile = (0, providerProfiles_1.buildProviderProfileExport)(params.providers, params.now ?? new Date());
+    const outputPath = await writePluginConfigJsonFile(params.host, params.pluginId, exports.PROVIDER_PROFILE_FILE_NAME, profile);
+    return { outputPath, profile };
+}
+async function executeImportProviderProfilesCommand(params) {
+    const inputPath = buildPluginConfigFilePath(params.host.configDir, params.pluginId, exports.PROVIDER_PROFILE_FILE_NAME);
+    if (!(await params.host.exists(inputPath))) {
+        throw new MissingProviderProfileImportFileError(inputPath);
+    }
+    const jsonData = await params.host.read(inputPath);
+    const importSummary = (0, providerProfiles_1.parseProviderProfileImport)(jsonData, params.existingProviders);
+    const activeProviderState = resolveImportedActiveProvider(importSummary.importedProviders, params.activeProvider, params.defaultActiveProvider);
+    return {
+        ...importSummary,
+        inputPath,
+        activeProvider: activeProviderState.activeProvider,
+        activeProviderReset: activeProviderState.activeProviderReset
+    };
+}
+async function executeExportCliCapabilityManifestCommand(params) {
+    const manifest = (0, capabilityManifest_1.buildCliCapabilityManifest)(params.pluginId);
+    const outputPath = await writePluginConfigJsonFile(params.host, params.pluginId, exports.CLI_CAPABILITY_MANIFEST_FILE_NAME, manifest);
+    return { outputPath, manifest };
+}
+async function executeExportCliInvocationContractCommand(params) {
+    const contract = (0, cliContracts_1.buildCliInvocationContract)();
+    const outputPath = await writePluginConfigJsonFile(params.host, params.pluginId, exports.CLI_INVOCATION_CONTRACT_FILE_NAME, contract);
+    return { outputPath, contract };
+}

package/dist/src/notemd/operations/registry.contract.test.js

@@ -0,0 +1,95 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * Operations Registry contract test (cline co-located pattern).
+ * Validates all 27 operation definitions for structural integrity,
+ * schema correctness, automation level consistency, and required fields.
+ */
+const registry_1 = require("./registry");
+const VALID_AUTOMATION_LEVELS = ['safe', 'requires-active-file', 'requires-selection', 'interactive-ui'];
+const VALID_SIDE_EFFECTS = ['read-only', 'write-file', 'batch-write', 'preview-ui', 'destructive'];
+const VALID_CONTEXTS = ['none', 'active-file', 'editor-selection', 'folder-selection', 'preview-ui'];
+describe('Operations Registry', () => {
+    let ops;
+    beforeAll(() => { ops = (0, registry_1.listOperationDefinitions)(); });
+    test('returns 27 operation definitions', () => {
+        expect(ops.length).toBe(27);
+    });
+    test('every operation has a unique id', () => {
+        const ids = ops.map(o => o.id);
+        expect(new Set(ids).size).toBe(ids.length);
+    });
+    test('every operation has version 1', () => {
+        ops.forEach(o => expect(o.version).toBe(1));
+    });
+    test('every operation has valid automationLevel', () => {
+        ops.forEach(o => expect(VALID_AUTOMATION_LEVELS).toContain(o.automationLevel));
+    });
+    test('every operation has valid sideEffectClass', () => {
+        ops.forEach(o => expect(VALID_SIDE_EFFECTS).toContain(o.sideEffectClass));
+    });
+    test('every operation has valid requiredContext', () => {
+        ops.forEach(o => expect(VALID_CONTEXTS).toContain(o.requiredContext));
+    });
+    test('every operation has at least one command binding', () => {
+        ops.forEach(o => expect(o.commandBindings.length).toBeGreaterThanOrEqual(1));
+    });
+    test('every command binding has a non-empty commandId', () => {
+        ops.forEach(o => o.commandBindings.forEach(b => {
+            expect(b.commandId.length).toBeGreaterThan(0);
+        }));
+    });
+    test('safe operations have read-only or write-file side effects', () => {
+        const safeOps = ops.filter(o => o.automationLevel === 'safe');
+        safeOps.forEach(o => {
+            expect(['read-only', 'write-file']).toContain(o.sideEffectClass);
+        });
+    });
+    test('destructive operations require interactive-ui', () => {
+        const destructiveOps = ops.filter(o => o.sideEffectClass === 'destructive');
+        destructiveOps.forEach(o => {
+            expect(o.automationLevel).toBe('interactive-ui');
+        });
+    });
+    test('batch-write operations require at least active-file context', () => {
+        const batchOps = ops.filter(o => o.sideEffectClass === 'batch-write');
+        batchOps.forEach(o => {
+            expect(o.automationLevel).not.toBe('safe');
+        });
+    });
+    test('getOperationDefinition returns correct op by id', () => {
+        const op = (0, registry_1.getOperationDefinition)('diagram.generate');
+        expect(op).toBeDefined();
+        expect(op.id).toBe('diagram.generate');
+        expect(op.automationLevel).toBe('safe');
+    });
+    test('getOperationDefinition returns undefined for unknown id', () => {
+        expect((0, registry_1.getOperationDefinition)('nonexistent.op')).toBeUndefined();
+    });
+    test('every operation with inputSchema has a valid JSON schema', () => {
+        ops.filter(o => o.inputSchema).forEach(o => {
+            expect(o.inputSchema).toBeDefined();
+            expect(typeof o.inputSchema.type).toBe('string');
+        });
+    });
+    test('critical operations exist', () => {
+        const ids = ops.map(o => o.id);
+        expect(ids).toContain('file.process-add-links');
+        expect(ids).toContain('diagram.generate');
+        expect(ids).toContain('translate.file');
+        expect(ids).toContain('provider.diagnostic.run');
+        expect(ids).toContain('workflow.extract-and-generate');
+        expect(ids).toContain('workflow.batch');
+        expect(ids).toContain('mermaid.batch-fix');
+        expect(ids).toContain('content.generate-from-title');
+        expect(ids).toContain('cli.capability-manifest.export');
+        expect(ids).toContain('cli.invocation-contract.export');
+    });
+    test('capability-manifest ops are safe and read-only', () => {
+        const cliOps = ops.filter(o => o.id.startsWith('cli.'));
+        cliOps.forEach(o => {
+            expect(o.automationLevel).toBe('safe');
+            expect(o.sideEffectClass).toBe('write-file');
+        });
+    });
+});