noteconnection 1.8.0 → 1.9.0

package/dist/src/mobile.profile.contract.test.js

@@ -0,0 +1,225 @@
+"use strict";
+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 crypto = __importStar(require("crypto"));
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const PlatformCapabilities_1 = require("./platform/PlatformCapabilities");
+const RenderMaterializer_1 = require("./platform/RenderMaterializer");
+describe('mobile-slim profile contract', () => {
+    const repoRoot = path.resolve(__dirname, '..');
+    const analyzerPath = path.join(repoRoot, 'src', 'frontend', 'mobile_exact_analyzer.js');
+    const projectionContractPath = path.join(repoRoot, 'src', 'frontend', 'knowledge_projection_contract.js');
+    const verifierPath = path.join(repoRoot, 'scripts', 'verify-mobile-slim-budget.js');
+    const preparePath = path.join(repoRoot, 'scripts', 'prepare-mobile-slim.js');
+    test('declares sidecar-free local analysis with optional remote inference and hard budgets', () => {
+        const capabilities = (0, PlatformCapabilities_1.resolvePlatformCapabilities)({ exportProfileId: 'mobile-slim' });
+        expect(capabilities.retrieval.supportsSidecar).toBe(false);
+        expect(capabilities.retrieval.supportsLocalIngest).toBe(true);
+        expect(capabilities.retrieval.supportsLocalExactQuery).toBe(true);
+        expect(capabilities.retrieval.supportsRemoteInference).toBe(true);
+        expect(capabilities.retrieval.requiresRemoteInference).toBe(false);
+        expect(capabilities.export.assetBudgetBytes).toBe(25 * 1024 * 1024);
+        expect(capabilities.export.maxResidentBytes).toBe(256 * 1024 * 1024);
+    });
+    test('rejects SVG materialization for mobile even when explicitly requested', () => {
+        const decision = (0, RenderMaterializer_1.resolveRenderMaterializationDecision)({
+            exportProfileId: 'mobile-slim',
+            includeSvg: true,
+            includeStages: true,
+            rendererPreference: 'frontend',
+        });
+        expect(decision.includeSvg).toBe(false);
+        expect(decision.vectorSuppressed).toBe(true);
+        expect(decision.responseArtifact).toBe('png');
+        expect(decision.rendererPreference).toBe('local');
+    });
+    test('ships a callable bounded exact graph analyzer without retaining document bodies', () => {
+        expect(fs.existsSync(analyzerPath)).toBe(true);
+        const analyzer = require(analyzerPath);
+        const index = analyzer.createMobileExactIndex({
+            nodes: [
+                { id: 'fundamentals/alpha', label: 'Alpha', content: 'must not be retained' },
+                { id: 'fundamentals/beta', label: 'Beta', metadata: { tags: ['core'] } },
+                { id: 'advanced/gamma', label: 'Gamma' },
+            ],
+            edges: [
+                { source: 'fundamentals/alpha', target: 'fundamentals/beta', type: 'prerequisite' },
+                { source: 'fundamentals/beta', target: 'advanced/gamma', type: 'next' },
+            ],
+        });
+        expect(index.searchExact('beta')).toEqual([
+            expect.objectContaining({ id: 'fundamentals/beta' }),
+        ]);
+        expect(index.searchExact('core')).toEqual([
+            expect.objectContaining({ id: 'fundamentals/beta' }),
+        ]);
+        expect(index.neighbors('fundamentals/beta')).toEqual([
+            expect.objectContaining({ id: 'advanced/gamma' }),
+            expect.objectContaining({ id: 'fundamentals/alpha' }),
+        ]);
+        expect(index.shortestPath('fundamentals/alpha', 'advanced/gamma')).toEqual([
+            'fundamentals/alpha',
+            'fundamentals/beta',
+            'advanced/gamma',
+        ]);
+        expect(index.statistics()).toEqual({ nodeCount: 3, edgeCount: 2 });
+        expect(JSON.stringify(index.searchExact('alpha'))).not.toContain('must not be retained');
+    });
+    test('normalizes exact lookup keys independently of the device locale', () => {
+        const analyzerSource = fs.readFileSync(analyzerPath, 'utf8');
+        const analyzer = require(analyzerPath);
+        const index = analyzer.createMobileExactIndex({
+            nodes: [{ id: 'unicode-i', label: '\u0130' }],
+            edges: [],
+        });
+        expect(analyzerSource).not.toContain('.toLocaleLowerCase(');
+        expect(index.searchExact('i\u0307')).toEqual([
+            expect.objectContaining({ id: 'unicode-i' }),
+        ]);
+    });
+    test('does not cross the requested visited-node ceiling during path traversal', () => {
+        const analyzer = require(analyzerPath);
+        const index = analyzer.createMobileExactIndex({
+            nodes: [
+                { id: 'source' },
+                { id: 'first-branch' },
+                { id: 'target' },
+            ],
+            edges: [
+                { source: 'source', target: 'first-branch' },
+                { source: 'source', target: 'target' },
+            ],
+        });
+        expect(index.shortestPath('source', 'target', 2, 2)).toBeNull();
+    });
+    test('exposes exact query and path operations through the runtime storage boundary', () => {
+        const storageProvider = fs.readFileSync(path.join(repoRoot, 'src', 'frontend', 'storage_provider.js'), 'utf8');
+        const indexHtml = fs.readFileSync(path.join(repoRoot, 'src', 'frontend', 'index.html'), 'utf8');
+        const analyzerScriptOffset = indexHtml.indexOf('<script src="mobile_exact_analyzer.js"></script>');
+        const identityScriptOffset = indexHtml.indexOf('<script src="mobile_identity_contract.js"></script>');
+        const storageScriptOffset = indexHtml.indexOf('<script src="storage_provider.js"></script>');
+        expect(storageProvider).toContain('async queryKnowledgeBaseExact(request)');
+        expect(storageProvider).toContain('async findKnowledgePath(request)');
+        expect(storageProvider).toContain("this.readGeneratedAsset('graph_data.json')");
+        expect(analyzerScriptOffset).toBeGreaterThan(-1);
+        expect(identityScriptOffset).toBeGreaterThan(analyzerScriptOffset);
+        expect(identityScriptOffset).toBeLessThan(storageScriptOffset);
+        expect(analyzerScriptOffset).toBeLessThan(storageScriptOffset);
+    });
+    test('loads one versioned projection contract before both mobile consumers', () => {
+        const projectionContract = fs.readFileSync(projectionContractPath, 'utf8');
+        const storageProvider = fs.readFileSync(path.join(repoRoot, 'src', 'frontend', 'storage_provider.js'), 'utf8');
+        const indexHtml = fs.readFileSync(path.join(repoRoot, 'src', 'frontend', 'index.html'), 'utf8');
+        const projectionScriptOffset = indexHtml.indexOf('<script src="knowledge_projection_contract.js"></script>');
+        expect(projectionContract).toContain('schemaVersion: SCHEMA_VERSION');
+        expect(projectionContract).toContain('MAX_NEIGHBORS');
+        expect(storageProvider).toContain('window.NoteConnectionKnowledgeProjection');
+        expect(storageProvider).toContain('createKnowledgeProjection');
+        expect(storageProvider).toContain('createFileProjectionStore');
+        expect(storageProvider).toContain("fileName: 'graph_data.json'");
+        expect(projectionScriptOffset).toBeGreaterThan(-1);
+        expect(projectionScriptOffset).toBeLessThan(indexHtml.indexOf('<script src="mobile_exact_analyzer.js"></script>'));
+        expect(projectionScriptOffset).toBeLessThan(indexHtml.indexOf('<script src="storage_provider.js"></script>'));
+    });
+    test('fails closed for oversized, forbidden, and over-RSS mobile staging evidence', () => {
+        expect(fs.existsSync(verifierPath)).toBe(true);
+        const verifier = require(verifierPath);
+        const fixtureRoot = fs.mkdtempSync(path.join(repoRoot, '.mobile-slim-contract-'));
+        try {
+            fs.writeFileSync(path.join(fixtureRoot, 'index.html'), crypto.randomBytes(2048));
+            expect(() => verifier.assertMobileSlimBudget({
+                stagingDir: fixtureRoot,
+                assetBudgetBytes: 128,
+                maxResidentBytes: 1024,
+            })).toThrow(/compressed payload/i);
+            fs.rmSync(path.join(fixtureRoot, 'index.html'));
+            fs.writeFileSync(path.join(fixtureRoot, 'server-aarch64-linux'), 'forbidden');
+            expect(() => verifier.assertMobileSlimBudget({
+                stagingDir: fixtureRoot,
+                assetBudgetBytes: 4096,
+                maxResidentBytes: 1024,
+            })).toThrow(/forbidden mobile artifact/i);
+            fs.rmSync(path.join(fixtureRoot, 'server-aarch64-linux'));
+            fs.writeFileSync(path.join(fixtureRoot, 'index.html'), 'ok');
+            const rssEvidencePath = path.join(fixtureRoot, 'rss-evidence.json');
+            fs.writeFileSync(rssEvidencePath, JSON.stringify({ peakResidentBytes: 2048 }));
+            expect(() => verifier.assertMobileSlimBudget({
+                stagingDir: fixtureRoot,
+                assetBudgetBytes: 4096,
+                maxResidentBytes: 1024,
+                rssEvidencePath,
+            })).toThrow(/peak RSS/i);
+        }
+        finally {
+            fs.rmSync(fixtureRoot, { recursive: true, force: true });
+        }
+    });
+    test('routes both Android packagers through the deterministic mobile staging directory', () => {
+        expect(fs.existsSync(preparePath)).toBe(true);
+        const pkg = JSON.parse(fs.readFileSync(path.join(repoRoot, 'package.json'), 'utf8'));
+        const capacitorConfig = fs.readFileSync(path.join(repoRoot, 'capacitor.config.ts'), 'utf8');
+        const capacitorBuild = fs.readFileSync(path.join(repoRoot, 'build_apk.bat'), 'utf8');
+        const tauriAndroidConfig = JSON.parse(fs.readFileSync(path.join(repoRoot, 'src-tauri', 'tauri.android.conf.json'), 'utf8'));
+        expect(pkg.scripts['mobile:prepare:slim']).toContain('prepare-mobile-slim.js');
+        expect(pkg.scripts['mobile:prepare:slim']).toContain('verify-mobile-slim-budget.js');
+        expect(pkg.scripts['tauri:android:init']).toContain('mobile:prepare:slim');
+        expect(pkg.scripts['verify:mobile:slim:budget']).toContain('verify-mobile-slim-budget.js');
+        expect(pkg.scripts['tauri:android:build']).toContain('mobile:prepare:slim');
+        expect(pkg.scripts['tauri:android:build']).not.toContain('build:sidecar');
+        expect(capacitorConfig).toContain('NOTE_CONNECTION_MOBILE_WEB_DIR');
+        expect(capacitorBuild).toContain('npm run mobile:prepare:slim');
+        expect(capacitorBuild).toContain('NOTE_CONNECTION_MOBILE_WEB_DIR');
+        expect(tauriAndroidConfig.build?.frontendDist).toBe('../dist/mobile-slim/frontend');
+        expect(tauriAndroidConfig.bundle?.externalBin).toEqual([]);
+    });
+    test('keeps Godot Android integration explicit instead of enabling it in mobile-slim', () => {
+        const runner = fs.readFileSync(path.join(repoRoot, 'scripts', 'run-tauri-android.js'), 'utf8');
+        const patcher = fs.readFileSync(path.join(repoRoot, 'scripts', 'apply-tauri-android-pathmode.js'), 'utf8');
+        expect(runner).toContain('NOTE_CONNECTION_ANDROID_INCLUDE_GODOT_PATHMODE');
+        expect(runner).toContain("runPathmodePatch({ mode: 'disable'");
+        expect(patcher).toContain("process.argv.includes('--disable')");
+        expect(patcher).toContain('removePathmodeAssets');
+    });
+    test('keeps the semantic comparator out of mobile-slim runtime staging', () => {
+        const prepareSource = fs.readFileSync(preparePath, 'utf8');
+        expect(prepareSource).toContain('mobile_semantic_comparator\\.js');
+    });
+    test('does not allocate the full-content graph on Android runtime builds', () => {
+        const rustSource = fs.readFileSync(path.join(repoRoot, 'src-tauri', 'src', 'lib.rs'), 'utf8');
+        expect(rustSource).toContain('#[cfg(not(target_os = "android"))]\n    let full_nodes');
+        expect(rustSource).toContain('#[cfg(not(target_os = "android"))]\n    let full_graph');
+    });
+});

package/dist/src/mobile.semantic.parity.test.js

@@ -0,0 +1,92 @@
+"use strict";
+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 path = __importStar(require("path"));
+const comparator = require(path.resolve(__dirname, 'frontend', 'mobile_semantic_comparator.js'));
+const projectionContract = require(path.resolve(__dirname, 'frontend', 'knowledge_projection_contract.js'));
+describe('cross-host mobile semantic parity', () => {
+    test('matches canonical nodes and directed edge provenance across host-specific ids', () => {
+        const left = projectionContract.createKnowledgeProjection({
+            nodes: [
+                { id: 'base', canonicalId: 'financial/base', sourceUri: 'note://workspace/v1/financial/base.md' },
+                { id: 'intro', canonicalId: 'financial/intro', sourceUri: 'note://workspace/v1/financial/intro.md' },
+            ],
+            edges: [{
+                    source: 'base',
+                    target: 'intro',
+                    sourceUri: 'note://workspace/v1/financial/base.md',
+                    targetUri: 'note://workspace/v1/financial/intro.md',
+                    type: 'explicit-prerequisite',
+                    kind: 'explicit',
+                    provenance: 'explicit-prerequisite',
+                }],
+        });
+        const right = projectionContract.createKnowledgeProjection({
+            nodes: [
+                { id: 'financial/base', canonicalId: 'financial/base', sourceUri: 'note://workspace/v1/financial/base.md' },
+                { id: 'financial/intro', canonicalId: 'financial/intro', sourceUri: 'note://workspace/v1/financial/intro.md' },
+            ],
+            edges: [{
+                    source: 'financial/base',
+                    target: 'financial/intro',
+                    type: 'explicit-prerequisite',
+                    kind: 'explicit',
+                    provenance: 'explicit-prerequisite',
+                }],
+        });
+        expect(comparator.compareSemanticProjections(left, right).equal).toBe(true);
+        expect(() => comparator.assertSemanticParity(left, right, 'fixture')).not.toThrow();
+    });
+    test('reports provenance changes instead of collapsing same-endpoint edges', () => {
+        const left = {
+            nodes: [
+                { id: 'a', canonicalId: 'a', sourceUri: 'note://workspace/v1/a.md' },
+                { id: 'b', canonicalId: 'b', sourceUri: 'note://workspace/v1/b.md' },
+            ],
+            edges: [{ source: 'a', target: 'b', type: 'wiki-link', provenance: 'wiki-link' }],
+        };
+        const right = {
+            nodes: [
+                { id: 'a', canonicalId: 'a', sourceUri: 'note://workspace/v1/a.md' },
+                { id: 'b', canonicalId: 'b', sourceUri: 'note://workspace/v1/b.md' },
+            ],
+            edges: [{ source: 'a', target: 'b', type: 'markdown-link', provenance: 'markdown-link' }],
+        };
+        const comparison = comparator.compareSemanticProjections(left, right);
+        expect(comparison.equal).toBe(false);
+        expect(comparison.extraEdges.length).toBeGreaterThan(0);
+        expect(() => comparator.assertSemanticParity(left, right, 'provenance')).toThrow(/semantic projection parity failed/);
+    });
+});

package/dist/src/mobile_exact_analyzer.test.js

@@ -0,0 +1,113 @@
+"use strict";
+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 path = __importStar(require("path"));
+// The analyzer is deliberately a browser-compatible CommonJS/IIFE artifact so
+// the same projection can be replayed in Capacitor and the desktop test runner.
+const analyzer = require(path.resolve(__dirname, 'frontend', 'mobile_exact_analyzer.js'));
+describe('mobile exact projection contract', () => {
+    test('indexes stable URI aliases and separates explicit from inferred edges', () => {
+        const index = analyzer.createMobileExactIndex({
+            nodes: [
+                {
+                    id: 'Legacy A',
+                    label: 'A',
+                    sourceUri: 'note://workspace/v1/a.md',
+                    identityAliases: ['a.md'],
+                    metadata: { tags: ['algebra'] },
+                },
+                { id: 'B', label: 'B' },
+            ],
+            edges: [
+                { source: 'Legacy A', target: 'B', type: 'explicit-prerequisite' },
+                { source: 'B', target: 'Legacy A', type: 'vector-association' },
+            ],
+        });
+        expect(index.searchExact('note://workspace/v1/a.md', 5)[0]).toEqual(expect.objectContaining({
+            id: 'Legacy A',
+            sourceUri: 'note://workspace/v1/a.md',
+        }));
+        expect(index.neighbors('note://workspace/v1/a.md', 5, ['explicit'])).toEqual([
+            expect.objectContaining({ id: 'B', edgeKind: 'explicit' }),
+        ]);
+        expect(index.statistics({ includeProvenance: true })).toEqual(expect.objectContaining({
+            projectionVersion: 1,
+            edgeCount: 2,
+            explicitEdgeCount: 1,
+            inferredEdgeCount: 1,
+        }));
+    });
+    test('resolves a source URI in bounded path queries', () => {
+        const index = analyzer.createMobileExactIndex({
+            nodes: [
+                { id: 'A', sourceUri: 'note://workspace/v1/a.md' },
+                { id: 'B', sourceUri: 'note://workspace/v1/b.md' },
+            ],
+            edges: [{ source: 'A', target: 'B', type: 'sequence' }],
+        });
+        expect(index.shortestPath('note://workspace/v1/a.md', 'note://workspace/v1/b.md', 4, 10)).toEqual(['A', 'B']);
+    });
+    test('resolves a path-derived canonical id without changing the legacy node id', () => {
+        const index = analyzer.createMobileExactIndex({
+            nodes: [{ id: 'Index', canonicalId: 'algebra/index', label: 'Index' }],
+            edges: [],
+        });
+        expect(index.searchExact('algebra/index', 5)).toEqual([
+            expect.objectContaining({ id: 'Index', canonicalId: 'algebra/index' }),
+        ]);
+    });
+    test('builds a bounded prerequisite-aware learning route from explicit graph edges', () => {
+        const index = analyzer.createMobileExactIndex({
+            nodes: [
+                { id: 'water', label: 'Water molecules' },
+                { id: 'ice', label: 'Amorphous ice' },
+                { id: 'rdf', label: 'Radial distribution function g(r)' },
+                { id: 'application', label: 'Applications' },
+            ],
+            edges: [
+                { source: 'water', target: 'ice', type: 'explicit-prerequisite' },
+                { source: 'ice', target: 'rdf', type: 'sequence' },
+                { source: 'ice', target: 'application', type: 'application' },
+            ],
+        });
+        expect(index.learningRoute('ice', 6)).toEqual([
+            expect.objectContaining({ nodeId: 'water', role: 'prerequisite', order: 1, orderingBasis: 'explicit_prerequisite' }),
+            expect.objectContaining({ nodeId: 'ice', role: 'core', order: 2 }),
+            expect.objectContaining({ nodeId: 'rdf', role: 'mechanism', order: 3 }),
+            expect.objectContaining({ nodeId: 'application', role: 'application', order: 4 }),
+        ]);
+        expect(index.learningRoute('ice', 2)).toHaveLength(2);
+    });
+});

package/dist/src/notemd/ContentGenerator.js

@@ -41,12 +41,7 @@ const constants_1 = require("./constants");
 const LlmProvider_1 = require("./LlmProvider");
 const PromptManager_1 = require("./PromptManager");
 const types_1 = require("./types");
-function defaultReporter() {
-    return {
-        report: () => undefined,
-        isCancelled: () => false,
-    };
-}
+const progressReporter_1 = require("./progressReporter");
 function isTextExtension(filePath) {
     return constants_1.NOTEMD_SUPPORTED_TEXT_EXTENSIONS.has(path.extname(filePath).toLowerCase());
 }
@@ -56,7 +51,7 @@ class ContentGenerator {
         this.promptManager = promptManager;
         this.batchProcessor = batchProcessor;
     }
-    async generateFromTitle(request, settings, reporter = defaultReporter(), signal) {
+    async generateFromTitle(request, settings, reporter = (0, progressReporter_1.createNoopProgressReporter)(), signal) {
         const title = String(request.title || '').trim();
         if (!title) {
             throw new types_1.ValidationError('Missing title.');
@@ -90,7 +85,7 @@ class ContentGenerator {
         reporter.report({ type: 'done', message: `Generated content for "${title}"`, percent: 100 });
         return result.text.trim();
     }
-    async generateForFile(filePath, settings, reporter = defaultReporter(), signal) {
+    async generateForFile(filePath, settings, reporter = (0, progressReporter_1.createNoopProgressReporter)(), signal) {
         const absoluteFilePath = path.resolve(String(filePath || '').trim());
         if (!absoluteFilePath) {
             throw new types_1.ValidationError('Missing file path.');
@@ -113,7 +108,7 @@ class ContentGenerator {
             generated: true,
         };
     }
-    async generateFolderFromTitles(folderPath, settings, reporter = defaultReporter(), signal) {
+    async generateFolderFromTitles(folderPath, settings, reporter = (0, progressReporter_1.createNoopProgressReporter)(), signal) {
         const absoluteFolder = path.resolve(String(folderPath || '').trim());
         if (!absoluteFolder) {
             throw new types_1.ValidationError('Missing folder path.');

package/dist/src/notemd/FileProcessor.js

@@ -42,6 +42,7 @@ const LlmProvider_1 = require("./LlmProvider");
 const PromptManager_1 = require("./PromptManager");
 const types_1 = require("./types");
 const constants_1 = require("./constants");
+const progressReporter_1 = require("./progressReporter");
 function countWords(text) {
     return text
         .trim()
@@ -71,12 +72,6 @@ function looksLikeConcept(raw) {
     }
     return true;
 }
-function defaultReporter() {
-    return {
-        report: () => undefined,
-        isCancelled: () => false,
-    };
-}
 class FileProcessor {
     constructor(llmClient = new LlmProvider_1.LlmProviderClient(), promptManager = new PromptManager_1.PromptManager(), duplicateDetector = new DuplicateDetector_1.DuplicateDetector(), batchProcessor = new BatchProcessor_1.BatchProcessor()) {
         this.llmClient = llmClient;
@@ -105,7 +100,7 @@ class FileProcessor {
         }
         return chunks.length > 0 ? chunks : [String(content || '')];
     }
-    async extractConceptsFromText(content, settings, reporter = defaultReporter(), signal) {
+    async extractConceptsFromText(content, settings, reporter = (0, progressReporter_1.createNoopProgressReporter)(), signal) {
         const concepts = new Set();
         const chunks = this.splitContent(content, settings.chunkWordCount);
         const provider = (0, LlmProvider_1.selectProviderForTask)(settings, 'extractConcepts');
@@ -151,7 +146,7 @@ class FileProcessor {
         }
         return concepts;
     }
-    async processFile(request, settings, reporter = defaultReporter(), signal) {
+    async processFile(request, settings, reporter = (0, progressReporter_1.createNoopProgressReporter)(), signal) {
         const filePath = path.resolve(String(request.filePath || '').trim());
         if (!filePath) {
             throw new types_1.ValidationError('Missing filePath.');
@@ -208,7 +203,7 @@ class FileProcessor {
             changed,
         };
     }
-    async processFolder(request, settings, reporter = defaultReporter(), signal) {
+    async processFolder(request, settings, reporter = (0, progressReporter_1.createNoopProgressReporter)(), signal) {
         const folderPath = path.resolve(String(request.folderPath || '').trim());
         if (!folderPath) {
             throw new types_1.ValidationError('Missing folderPath.');

package/dist/src/notemd/NotemdService.js

@@ -47,12 +47,7 @@ const SearchManager_1 = require("./search/SearchManager");
 const diagramGenerationService_1 = require("./diagram/diagramGenerationService");
 const LlmProvider_1 = require("./LlmProvider");
 const types_1 = require("./types");
-function defaultReporter() {
-    return {
-        report: () => undefined,
-        isCancelled: () => false,
-    };
-}
+const progressReporter_1 = require("./progressReporter");
 class NotemdService {
     constructor(fileProcessor = new FileProcessor_1.FileProcessor(), translator = new Translator_1.Translator(), contentGenerator = new ContentGenerator_1.ContentGenerator(), mermaidProcessor = new MermaidProcessor_1.MermaidProcessor(), formulaFixer = new FormulaFixer_1.FormulaFixer(), duplicateDetector = new DuplicateDetector_1.DuplicateDetector(), llmProviderClient = new LlmProvider_1.LlmProviderClient()) {
         // ── Batch progress tracking ──
@@ -65,22 +60,22 @@ class NotemdService {
         this.duplicateDetector = duplicateDetector;
         this.llmProviderClient = llmProviderClient;
     }
-    processFile(request, settings, reporter = defaultReporter(), signal) {
+    processFile(request, settings, reporter = (0, progressReporter_1.createNoopProgressReporter)(), signal) {
         return this.fileProcessor.processFile(request, settings, reporter, signal);
     }
-    processFolder(request, settings, reporter = defaultReporter(), signal) {
+    processFolder(request, settings, reporter = (0, progressReporter_1.createNoopProgressReporter)(), signal) {
         return this.fileProcessor.processFolder(request, settings, reporter, signal);
     }
-    translateFile(request, settings, reporter = defaultReporter(), signal) {
+    translateFile(request, settings, reporter = (0, progressReporter_1.createNoopProgressReporter)(), signal) {
         return this.translator.translateFile(request, settings, reporter, signal);
     }
-    translateFolder(folderPath, targetLanguage, settings, reporter = defaultReporter(), signal) {
+    translateFolder(folderPath, targetLanguage, settings, reporter = (0, progressReporter_1.createNoopProgressReporter)(), signal) {
         return this.translator.translateFolder(folderPath, targetLanguage, settings, reporter, signal);
     }
-    generateContent(title, context, settings, reporter = defaultReporter(), signal) {
+    generateContent(title, context, settings, reporter = (0, progressReporter_1.createNoopProgressReporter)(), signal) {
         return this.contentGenerator.generateFromTitle({ title, context }, settings, reporter, signal);
     }
-    generateFolderContent(folderPath, settings, reporter = defaultReporter(), signal) {
+    generateFolderContent(folderPath, settings, reporter = (0, progressReporter_1.createNoopProgressReporter)(), signal) {
         return this.contentGenerator.generateFolderFromTitles(folderPath, settings, reporter, signal);
     }
     async batchFixMermaid(folderPath, inPlace = true) {
@@ -192,7 +187,7 @@ class NotemdService {
             duplicateWikiLinks: this.duplicateDetector.detectDuplicateWikiLinks(source),
         };
     }
-    async extractConcepts(filePath, settings, reporter = defaultReporter(), signal) {
+    async extractConcepts(filePath, settings, reporter = (0, progressReporter_1.createNoopProgressReporter)(), signal) {
         const resolvedPath = path.resolve(String(filePath || '').trim());
         if (!resolvedPath) {
             throw new types_1.ValidationError('Missing filePath.');
@@ -205,7 +200,7 @@ class NotemdService {
         };
     }
     // ── Workflow Pipeline (NoteConnection native) ──
-    async runWorkflow(request, settings, reporter = defaultReporter(), signal) {
+    async runWorkflow(request, settings, reporter = (0, progressReporter_1.createNoopProgressReporter)(), signal) {
         const resolvedPath = path.resolve(String(request.filePath || '').trim());
         if (!resolvedPath)
             throw new types_1.ValidationError('Missing filePath.');
@@ -326,7 +321,7 @@ class NotemdService {
             errors,
         };
     }
-    async runBatchWorkflow(request, settings, reporter = defaultReporter(), signal) {
+    async runBatchWorkflow(request, settings, reporter = (0, progressReporter_1.createNoopProgressReporter)(), signal) {
         const resolvedFolderPath = path.resolve(String(request.folderPath || '').trim());
         if (!resolvedFolderPath)
             throw new types_1.ValidationError('Missing folderPath.');
@@ -407,7 +402,7 @@ class NotemdService {
         };
     }
     // Backward-compatible wrapper — uses knowledge-base-root-relative output path
-    async oneClickExtract(filePath, settings, reporter = defaultReporter(), signal) {
+    async oneClickExtract(filePath, settings, reporter = (0, progressReporter_1.createNoopProgressReporter)(), signal) {
         const resolvedPath = path.resolve(String(filePath || '').trim());
         const kbRoot = this.resolveKnowledgeBaseRootForFile(resolvedPath);
         const outputFolderPath = path.join(kbRoot, path.basename(resolvedPath, path.extname(resolvedPath)));
@@ -597,7 +592,7 @@ class NotemdService {
         };
     }
     // ── Extract original text (obsidian-notemd v1.8.4) ──
-    async extractOriginalText(request, _settings, _reporter = defaultReporter(), _signal) {
+    async extractOriginalText(request, _settings, _reporter = (0, progressReporter_1.createNoopProgressReporter)(), _signal) {
         const resolvedPath = path.resolve(String(request.filePath || '').trim());
         if (!resolvedPath)
             throw new types_1.ValidationError('Missing filePath.');

package/dist/src/notemd/Translator.js

@@ -41,12 +41,7 @@ const constants_1 = require("./constants");
 const LlmProvider_1 = require("./LlmProvider");
 const PromptManager_1 = require("./PromptManager");
 const types_1 = require("./types");
-function defaultReporter() {
-    return {
-        report: () => undefined,
-        isCancelled: () => false,
-    };
-}
+const progressReporter_1 = require("./progressReporter");
 function countWords(text) {
     return text
         .trim()
@@ -80,7 +75,7 @@ class Translator {
         this.promptManager = promptManager;
         this.batchProcessor = batchProcessor;
     }
-    async translateText(content, targetLanguage, settings, reporter = defaultReporter(), signal) {
+    async translateText(content, targetLanguage, settings, reporter = (0, progressReporter_1.createNoopProgressReporter)(), signal) {
         const provider = (0, LlmProvider_1.selectProviderForTask)(settings, 'translate');
         const model = (0, LlmProvider_1.selectModelForTask)(settings, 'translate', provider);
         const chunks = splitByWordCount(content, settings.chunkWordCount);
@@ -117,7 +112,7 @@ class Translator {
         }
         return translatedChunks.join('\n\n').trim();
     }
-    async translateFile(request, settings, reporter = defaultReporter(), signal) {
+    async translateFile(request, settings, reporter = (0, progressReporter_1.createNoopProgressReporter)(), signal) {
         const filePath = path.resolve(String(request.filePath || '').trim());
         if (!filePath) {
             throw new types_1.ValidationError('Missing filePath.');
@@ -144,7 +139,7 @@ class Translator {
             changed: translated !== source || outputPath !== filePath,
         };
     }
-    async translateFolder(folderPath, targetLanguage, settings, reporter = defaultReporter(), signal) {
+    async translateFolder(folderPath, targetLanguage, settings, reporter = (0, progressReporter_1.createNoopProgressReporter)(), signal) {
         const root = path.resolve(String(folderPath || '').trim());
         const stats = await this.stat(root);
         if (!stats.isDirectory()) {