noteconnection 1.6.8 → 1.8.0

package/dist/src/utils/RuntimePaths.js

@@ -37,6 +37,7 @@ exports.resolveRuntimePaths = resolveRuntimePaths;
 const fs = __importStar(require("fs"));
 const os = __importStar(require("os"));
 const path = __importStar(require("path"));
+const platform_1 = require("./platform");
 function isDirectory(targetPath) {
     try {
         return fs.existsSync(targetPath) && fs.statSync(targetPath).isDirectory();
@@ -65,17 +66,6 @@ function pickExisting(candidates) {
     }
     return null;
 }
-function resolveAppDataRoot(cwd) {
-    const localAppData = process.env.LOCALAPPDATA || process.env.APPDATA;
-    if (localAppData) {
-        return path.join(localAppData, 'NoteConnection');
-    }
-    const home = process.env.HOME || process.env.USERPROFILE;
-    if (home) {
-        return path.join(home, '.noteconnection');
-    }
-    return path.join(cwd, '.noteconnection');
-}
 function ensureWritableDirectory(targetPath) {
     try {
         fs.mkdirSync(targetPath, { recursive: true });
@@ -138,15 +128,16 @@ function resolveRuntimePaths(moduleDir) {
         path.join(moduleDir, 'frontend')
     ].filter((v) => Boolean(v)));
     const frontendDir = pickExisting(frontendCandidates) || path.join(projectRoot, 'dist', 'src', 'frontend');
+    const appDataRoot = (0, platform_1.getAppDataDir)();
     const runtimeDataCandidates = uniqPaths([
         envRuntimeDataDir,
-        path.join(resolveAppDataRoot(cwd), 'runtime_data'),
+        path.join(appDataRoot, 'runtime_data'),
         path.join(projectRoot, 'runtime_data'),
         path.join(cwd, 'runtime_data'),
         path.join(os.tmpdir(), 'noteconnection', 'runtime_data')
     ].filter((v) => Boolean(v)));
     const runtimeDataDirCandidate = runtimeDataCandidates.find((candidate) => ensureWritableDirectory(candidate))
-        || path.join(resolveAppDataRoot(cwd), 'runtime_data');
+        || path.join(appDataRoot, 'runtime_data');
     if (!ensureWritableDirectory(runtimeDataDirCandidate)) {
         throw new Error(`Unable to provision writable runtime data directory: ${runtimeDataDirCandidate}`);
     }

package/dist/src/utils/platform.js

@@ -0,0 +1,153 @@
+"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 });
+exports.getPlatform = getPlatform;
+exports.getAppDataDir = getAppDataDir;
+exports.getConfigDir = getConfigDir;
+exports.getCacheDir = getCacheDir;
+exports.getSidecarName = getSidecarName;
+exports.getGodotEnv = getGodotEnv;
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+const cachedPlatform = detectPlatform();
+function detectPlatform() {
+    const rawOs = process.platform;
+    const rawArch = process.arch;
+    let osName;
+    if (rawOs === 'linux')
+        osName = 'linux';
+    else if (rawOs === 'darwin')
+        osName = 'macos';
+    else if (rawOs === 'win32')
+        osName = 'windows';
+    else if (rawOs === 'android')
+        osName = 'android';
+    else
+        osName = 'unknown';
+    let archName;
+    if (rawArch === 'x64')
+        archName = 'x64';
+    else if (rawArch === 'arm64')
+        archName = 'arm64';
+    else
+        archName = 'unknown';
+    const triplet = buildTargetTriple(osName, archName);
+    const exeSuffix = osName === 'windows' ? '.exe' : '';
+    const isWayland = osName === 'linux' && process.env.XDG_SESSION_TYPE === 'wayland';
+    return { os: osName, arch: archName, triplet, exeSuffix, isWayland };
+}
+function buildTargetTriple(osName, archName) {
+    switch (osName) {
+        case 'linux':
+            return `x86_64-unknown-linux-gnu`;
+        case 'macos':
+            return archName === 'arm64'
+                ? 'aarch64-apple-darwin'
+                : 'x86_64-apple-darwin';
+        case 'windows':
+            return 'x86_64-pc-windows-msvc';
+        default:
+            return `${process.arch}-unknown-${process.platform}`;
+    }
+}
+function getPlatform() {
+    return cachedPlatform;
+}
+function getAppDataDir() {
+    const home = os.homedir();
+    const platform = cachedPlatform.os;
+    switch (platform) {
+        case 'macos':
+            return path.join(home, 'Library', 'Application Support', 'NoteConnection');
+        case 'linux': {
+            const xdgData = process.env.XDG_DATA_HOME || path.join(home, '.local', 'share');
+            return path.join(xdgData, 'NoteConnection');
+        }
+        case 'windows': {
+            const localAppData = process.env.LOCALAPPDATA || path.join(home, 'AppData', 'Local');
+            return path.join(localAppData, 'NoteConnection');
+        }
+        default:
+            return path.join(home, '.noteconnection');
+    }
+}
+function getConfigDir() {
+    const home = os.homedir();
+    const platform = cachedPlatform.os;
+    switch (platform) {
+        case 'macos':
+            return path.join(home, 'Library', 'Preferences', 'NoteConnection');
+        case 'linux': {
+            const xdgConfig = process.env.XDG_CONFIG_HOME || path.join(home, '.config');
+            return path.join(xdgConfig, 'NoteConnection');
+        }
+        case 'windows': {
+            const appData = process.env.APPDATA || path.join(home, 'AppData', 'Roaming');
+            return path.join(appData, 'NoteConnection');
+        }
+        default:
+            return path.join(home, '.config', 'noteconnection');
+    }
+}
+function getCacheDir() {
+    const home = os.homedir();
+    const platform = cachedPlatform.os;
+    switch (platform) {
+        case 'macos':
+            return path.join(home, 'Library', 'Caches', 'NoteConnection');
+        case 'linux': {
+            const xdgCache = process.env.XDG_CACHE_HOME || path.join(home, '.cache');
+            return path.join(xdgCache, 'NoteConnection');
+        }
+        case 'windows': {
+            const localAppData = process.env.LOCALAPPDATA || path.join(home, 'AppData', 'Local');
+            return path.join(localAppData, 'NoteConnection', 'Cache');
+        }
+        default:
+            return path.join(home, '.cache', 'noteconnection');
+    }
+}
+function getSidecarName(baseName) {
+    return `${baseName}-${cachedPlatform.triplet}${cachedPlatform.exeSuffix}`;
+}
+function getGodotEnv() {
+    if (cachedPlatform.isWayland) {
+        return {
+            GDK_BACKEND: 'x11',
+            WEBKIT_DISABLE_DMABUF_RENDERER: '1',
+        };
+    }
+    return {};
+}

package/dist/src/workflows/WorkflowArtifactStore.js

@@ -0,0 +1,96 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WorkflowArtifactStore = void 0;
+class WorkflowArtifactStore {
+    constructor(nextId) {
+        this.nextId = nextId;
+        this.artifacts = [];
+    }
+    clonePayload(payload) {
+        return JSON.parse(JSON.stringify(payload || {}));
+    }
+    cloneArtifact(record) {
+        return {
+            ...record,
+            sourceResourceIds: [...record.sourceResourceIds],
+            sourceProjectionIds: [...record.sourceProjectionIds],
+            payload: this.clonePayload(record.payload),
+        };
+    }
+    recordArtifact(input) {
+        const record = {
+            artifactId: this.nextId('workflow_artifact'),
+            kind: input.kind,
+            sessionId: input.sessionId || null,
+            userId: input.userId || null,
+            workspaceId: input.workspaceId || null,
+            corpusId: input.corpusId || null,
+            title: input.title,
+            sourceResourceIds: Array.from(new Set(input.sourceResourceIds)).filter(Boolean),
+            sourceProjectionIds: Array.from(new Set(input.sourceProjectionIds)).filter(Boolean),
+            summary: input.summary,
+            payload: this.clonePayload(input.payload || {}),
+            status: input.status,
+            createdAt: input.recordedAt,
+            updatedAt: input.recordedAt,
+        };
+        this.artifacts.unshift(record);
+        if (this.artifacts.length > 400) {
+            this.artifacts.splice(400);
+        }
+        return this.cloneArtifact(record);
+    }
+    getArtifactById(artifactId) {
+        const normalizedArtifactId = String(artifactId || '').trim();
+        if (!normalizedArtifactId) {
+            return null;
+        }
+        const record = this.artifacts.find((artifact) => artifact.artifactId === normalizedArtifactId);
+        return record ? this.cloneArtifact(record) : null;
+    }
+    listAll() {
+        return this.artifacts.map((record) => this.cloneArtifact(record));
+    }
+    updateArtifact(artifactId, updater) {
+        const normalizedArtifactId = String(artifactId || '').trim();
+        if (!normalizedArtifactId) {
+            return null;
+        }
+        const index = this.artifacts.findIndex((artifact) => artifact.artifactId === normalizedArtifactId);
+        if (index < 0) {
+            return null;
+        }
+        const current = this.cloneArtifact(this.artifacts[index]);
+        const updated = updater(current);
+        this.artifacts[index] = this.cloneArtifact(updated);
+        return this.cloneArtifact(this.artifacts[index]);
+    }
+    listBySession(sessionId) {
+        return this.artifacts
+            .filter((record) => record.sessionId === String(sessionId || '').trim())
+            .map((record) => this.cloneArtifact(record));
+    }
+    listByWorkspace(workspaceId, userId) {
+        const normalizedWorkspaceId = String(workspaceId || '').trim().toLowerCase();
+        const normalizedUserId = String(userId || '').trim();
+        if (!normalizedWorkspaceId) {
+            return [];
+        }
+        return this.artifacts
+            .filter((record) => record.workspaceId === normalizedWorkspaceId)
+            .filter((record) => !normalizedUserId || record.userId === normalizedUserId)
+            .map((record) => this.cloneArtifact(record));
+    }
+    buildSnapshot() {
+        return {
+            artifacts: this.artifacts.map((artifact) => this.cloneArtifact(artifact)),
+        };
+    }
+    restoreFromSnapshot(snapshot) {
+        this.artifacts.length = 0;
+        (snapshot?.artifacts || []).forEach((artifact) => {
+            this.artifacts.push(this.cloneArtifact(artifact));
+        });
+    }
+}
+exports.WorkflowArtifactStore = WorkflowArtifactStore;

package/dist/src/workflows/WorkflowArtifactStore.test.js

@@ -0,0 +1,80 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const WorkflowArtifactStore_1 = require("./WorkflowArtifactStore");
+describe('WorkflowArtifactStore', () => {
+    test('records artifacts and lists them by session and workspace', () => {
+        let idCounter = 0;
+        const store = new WorkflowArtifactStore_1.WorkflowArtifactStore((prefix = 'workflow_artifact') => `${prefix}_${++idCounter}`);
+        const artifact = store.recordArtifact({
+            kind: 'knowledge_run',
+            sessionId: 'session_a',
+            userId: 'user_a',
+            workspaceId: 'optics',
+            corpusId: 'optics',
+            title: 'Knowledge run',
+            sourceResourceIds: ['resource_1'],
+            sourceProjectionIds: ['projection_1'],
+            summary: 'Evidence claims recorded',
+            payload: {
+                knowledgeRun: {
+                    runId: 'knowledge_run_1',
+                },
+            },
+            status: 'active',
+            recordedAt: '2026-05-26T00:00:00.000Z',
+        });
+        expect(store.listBySession('session_a')).toEqual([artifact]);
+        expect(store.listByWorkspace('optics')).toHaveLength(1);
+        const restored = new WorkflowArtifactStore_1.WorkflowArtifactStore((prefix = 'workflow_artifact') => `${prefix}_${++idCounter}`);
+        restored.restoreFromSnapshot(store.buildSnapshot());
+        expect(restored.listByWorkspace('optics')[0]?.artifactId).toBe(artifact.artifactId);
+    });
+    test('updates persisted artifacts without exposing mutable internal references', () => {
+        let idCounter = 0;
+        const store = new WorkflowArtifactStore_1.WorkflowArtifactStore((prefix = 'workflow_artifact') => `${prefix}_${++idCounter}`);
+        const artifact = store.recordArtifact({
+            kind: 'flashcard_batch',
+            sessionId: 'session_b',
+            userId: 'user_b',
+            workspaceId: 'optics',
+            corpusId: 'optics',
+            title: 'Review batch',
+            sourceResourceIds: ['resource_2'],
+            sourceProjectionIds: ['projection_2'],
+            summary: 'Prepared 1 review card.',
+            payload: {
+                reviewState: {
+                    consumedCardIds: [],
+                    completedReviewCardCount: 0,
+                    remainingReviewCardCount: 1,
+                    completedAt: null,
+                },
+            },
+            status: 'active',
+            recordedAt: '2026-05-26T01:00:00.000Z',
+        });
+        const updated = store.updateArtifact(artifact.artifactId, (current) => ({
+            ...current,
+            status: 'archived',
+            updatedAt: '2026-05-26T01:05:00.000Z',
+            payload: {
+                ...current.payload,
+                reviewState: {
+                    consumedCardIds: ['card_1'],
+                    completedReviewCardCount: 1,
+                    remainingReviewCardCount: 0,
+                    completedAt: '2026-05-26T01:05:00.000Z',
+                },
+            },
+        }));
+        expect(updated).not.toBeNull();
+        expect(updated?.status).toBe('archived');
+        expect((updated?.payload.reviewState).consumedCardIds).toEqual(['card_1']);
+        const fetched = store.getArtifactById(artifact.artifactId);
+        expect(fetched?.status).toBe('archived');
+        expect((fetched?.payload.reviewState).remainingReviewCardCount).toBe(0);
+        (updated?.payload.reviewState).consumedCardIds.push('card_2');
+        const refetched = store.getArtifactById(artifact.artifactId);
+        expect((refetched?.payload.reviewState).consumedCardIds).toEqual(['card_1']);
+    });
+});

package/dist/src/workflows/types.js

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

package/dist/src/workspace/WorkspaceRegistry.js

@@ -0,0 +1,122 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WorkspaceRegistry = void 0;
+class WorkspaceRegistry {
+    constructor(nextId) {
+        this.nextId = nextId;
+        this.workspaces = new Map();
+        this.bindings = new Map();
+        this.bindingIdsByDocumentId = new Map();
+    }
+    normalizePathPrefix(value) {
+        return String(value || '')
+            .trim()
+            .replace(/\\/g, '/')
+            .replace(/\/{2,}/g, '/')
+            .replace(/\/+$/g, '')
+            .toLowerCase();
+    }
+    inferCorpusIdFromSourcePath(sourcePath) {
+        const normalized = String(sourcePath || '').replace(/\\/g, '/');
+        const segments = normalized.split('/').filter(Boolean);
+        const normalizeSegment = (value) => String(value || '')
+            .trim()
+            .toLowerCase()
+            .replace(/\.[^.]+$/g, '');
+        const kbIndex = segments.findIndex((segment) => segment.toLowerCase() === 'knowledge_base');
+        if (kbIndex >= 0 && segments[kbIndex + 1]) {
+            return normalizeSegment(segments[kbIndex + 1]) || 'default';
+        }
+        return segments[0] ? normalizeSegment(segments[0]) || 'default' : 'default';
+    }
+    ensureWorkspace(params) {
+        const corpusId = String(params.corpusId || '').trim().toLowerCase()
+            || this.inferCorpusIdFromSourcePath(params.sourcePath);
+        const workspaceId = String(params.workspaceId || '').trim().toLowerCase() || corpusId;
+        const sourcePathPrefix = this.normalizePathPrefix(params.sourcePath).split('/').slice(0, 2).join('/');
+        const existing = this.workspaces.get(workspaceId);
+        const nextLanguage = String(params.language || 'unknown').trim().toLowerCase() || 'unknown';
+        const languages = Array.from(new Set([...(existing?.languages || []), nextLanguage])).sort((left, right) => left.localeCompare(right));
+        const record = {
+            workspaceId,
+            corpusId,
+            name: corpusId,
+            sourcePathPrefix,
+            languages,
+            exportProfileId: String(params.exportProfileId || existing?.exportProfileId || 'desktop-full').trim() || 'desktop-full',
+            status: 'active',
+            createdAt: existing?.createdAt || params.createdAt,
+            updatedAt: params.createdAt,
+        };
+        this.workspaces.set(workspaceId, record);
+        return record;
+    }
+    bindProjection(params) {
+        const documentId = String(params.documentId || '').trim();
+        const existingBindingId = documentId ? this.bindingIdsByDocumentId.get(documentId) || '' : '';
+        const bindingId = existingBindingId || this.nextId('workspace_binding');
+        const previousBinding = existingBindingId ? this.bindings.get(existingBindingId) || null : null;
+        const record = {
+            bindingId,
+            workspaceId: String(params.workspaceId || '').trim().toLowerCase(),
+            corpusId: String(params.corpusId || '').trim().toLowerCase(),
+            resourceId: params.resourceId,
+            projectionId: params.projectionId,
+            documentId: documentId || null,
+            sourcePath: params.sourcePath,
+            createdAt: previousBinding?.createdAt || params.boundAt,
+            updatedAt: params.boundAt,
+        };
+        this.bindings.set(bindingId, record);
+        if (documentId) {
+            this.bindingIdsByDocumentId.set(documentId, bindingId);
+        }
+        return record;
+    }
+    resolveBindingByDocumentId(documentId) {
+        const bindingId = this.bindingIdsByDocumentId.get(String(documentId || '').trim());
+        if (!bindingId) {
+            return null;
+        }
+        return this.bindings.get(bindingId) || null;
+    }
+    getWorkspaceById(workspaceId) {
+        return this.workspaces.get(String(workspaceId || '').trim().toLowerCase()) || null;
+    }
+    listBindingsByWorkspace(workspaceId) {
+        const normalizedWorkspaceId = String(workspaceId || '').trim().toLowerCase();
+        if (!normalizedWorkspaceId) {
+            return [];
+        }
+        return Array.from(this.bindings.values())
+            .filter((binding) => binding.workspaceId === normalizedWorkspaceId)
+            .sort((left, right) => left.bindingId.localeCompare(right.bindingId));
+    }
+    listActiveWorkspaces() {
+        return Array.from(this.workspaces.values()).filter((workspace) => workspace.status === 'active');
+    }
+    buildSnapshot() {
+        return {
+            workspaces: Array.from(this.workspaces.values()).map((workspace) => ({ ...workspace, languages: [...workspace.languages] })),
+            bindings: Array.from(this.bindings.values()).map((binding) => ({ ...binding })),
+        };
+    }
+    restoreFromSnapshot(snapshot) {
+        this.workspaces.clear();
+        this.bindings.clear();
+        this.bindingIdsByDocumentId.clear();
+        (snapshot?.workspaces || []).forEach((workspace) => {
+            this.workspaces.set(workspace.workspaceId, {
+                ...workspace,
+                languages: [...workspace.languages],
+            });
+        });
+        (snapshot?.bindings || []).forEach((binding) => {
+            this.bindings.set(binding.bindingId, { ...binding });
+            if (binding.documentId) {
+                this.bindingIdsByDocumentId.set(binding.documentId, binding.bindingId);
+            }
+        });
+    }
+}
+exports.WorkspaceRegistry = WorkspaceRegistry;

package/dist/src/workspace/WorkspaceRegistry.test.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const WorkspaceRegistry_1 = require("./WorkspaceRegistry");
+describe('WorkspaceRegistry', () => {
+    test('ensures workspace from source path and exposes bindings by workspace and document', () => {
+        let idCounter = 0;
+        const registry = new WorkspaceRegistry_1.WorkspaceRegistry((prefix = 'workspace') => `${prefix}_${++idCounter}`);
+        const workspace = registry.ensureWorkspace({
+            sourcePath: 'Knowledge_Base/optics/absorption.md',
+            language: 'zh',
+            exportProfileId: 'mobile-slim',
+            createdAt: '2026-05-26T00:00:00.000Z',
+        });
+        expect(workspace.workspaceId).toBe('optics');
+        expect(workspace.exportProfileId).toBe('mobile-slim');
+        const binding = registry.bindProjection({
+            workspaceId: workspace.workspaceId,
+            corpusId: workspace.corpusId,
+            resourceId: 'resource_1',
+            projectionId: 'projection_1',
+            documentId: 'doc_optics',
+            sourcePath: 'Knowledge_Base/optics/absorption.md',
+            boundAt: '2026-05-26T00:01:00.000Z',
+        });
+        expect(registry.resolveBindingByDocumentId('doc_optics')).toEqual(binding);
+        expect(registry.getWorkspaceById('optics')).toEqual(workspace);
+        expect(registry.listBindingsByWorkspace('optics')).toHaveLength(1);
+    });
+});

package/dist/src/workspace/types.js

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