escribano 0.2.2 → 0.4.1

package/dist/tests/db/repositories.test.js

@@ -38,9 +38,9 @@ function runRecordingRepositoryTests(name, createRepo) {
             });
             const found = repo.findById(id);
             expect(found).not.toBeNull();
-            expect(found.id).toBe(id);
-            expect(found.duration).toBe(120.5);
-            expect(found.status).toBe('raw');
+            expect(found?.id).toBe(id);
+            expect(found?.duration).toBe(120.5);
+            expect(found?.status).toBe('raw');
         });
         it('returns null for non-existent recording', () => {
             const found = repo.findById('nonexistent');
@@ -63,8 +63,8 @@ function runRecordingRepositoryTests(name, createRepo) {
             });
             repo.updateStatus(id, 'processing', 'clustering');
             const found = repo.findById(id);
-            expect(found.status).toBe('processing');
-            expect(found.processing_step).toBe('clustering');
+            expect(found?.status).toBe('processing');
+            expect(found?.processing_step).toBe('clustering');
         });
         it('finds pending recordings', () => {
             const id1 = generateId();
@@ -146,8 +146,8 @@ function runContextRepositoryTests(name, createRepos) {
             });
             const found = contextRepo.findById(id);
             expect(found).not.toBeNull();
-            expect(found.id).toBe(id);
-            expect(found.name).toBe('escribano');
+            expect(found?.id).toBe(id);
+            expect(found?.name).toBe('escribano');
         });
         it('finds by type and name', () => {
             const id = generateId();
@@ -159,7 +159,7 @@ function runContextRepositoryTests(name, createRepos) {
             });
             const found = contextRepo.findByTypeAndName('app', 'vscode');
             expect(found).not.toBeNull();
-            expect(found.id).toBe(id);
+            expect(found?.id).toBe(id);
         });
         it('links and unlinks observations', () => {
             const recordingId = generateId();

package/dist/tests/index.test.js

@@ -0,0 +1,102 @@
+import { chmod, mkdir, rm, stat, symlink, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import path from 'node:path';
+import { afterEach, beforeEach, describe, expect, it } from 'vitest';
+const VIDEO_EXTENSIONS = ['.mov', '.mp4', '.mkv', '.avi', '.webm'];
+function expandPath(inputPath) {
+    if (inputPath.startsWith('~/')) {
+        const homeDir = process.env.HOME || process.env.USERPROFILE || '';
+        return path.join(homeDir, inputPath.slice(2));
+    }
+    return inputPath;
+}
+async function findLatestVideo(dirPath) {
+    const resolvedPath = expandPath(dirPath);
+    const { readdir } = await import('node:fs/promises');
+    const entries = await readdir(resolvedPath, { withFileTypes: true });
+    const videoFiles = entries.filter((entry) => entry.isFile() &&
+        VIDEO_EXTENSIONS.some((ext) => entry.name.toLowerCase().endsWith(ext)));
+    if (videoFiles.length === 0) {
+        throw new Error(`No video files found in: ${resolvedPath}`);
+    }
+    const filesWithMtime = await Promise.all(videoFiles.map(async (entry) => {
+        const fullPath = path.join(resolvedPath, entry.name);
+        try {
+            const fileStat = await stat(fullPath);
+            return { path: fullPath, mtime: fileStat.mtime };
+        }
+        catch {
+            return null;
+        }
+    }));
+    const validFiles = filesWithMtime.filter((f) => f !== null);
+    if (validFiles.length === 0) {
+        throw new Error(`No accessible video files found in: ${resolvedPath}`);
+    }
+    validFiles.sort((a, b) => b.mtime.getTime() - a.mtime.getTime());
+    return validFiles[0].path;
+}
+describe('findLatestVideo', () => {
+    let testDir;
+    beforeEach(async () => {
+        testDir = path.join(tmpdir(), `escribano-test-${Date.now()}`);
+        await mkdir(testDir, { recursive: true });
+    });
+    afterEach(async () => {
+        await rm(testDir, { recursive: true, force: true });
+    });
+    it('returns the most recently modified video file', async () => {
+        const file1 = path.join(testDir, 'old.mp4');
+        const file2 = path.join(testDir, 'new.mov');
+        await writeFile(file1, 'old');
+        await new Promise((r) => setTimeout(r, 10));
+        await writeFile(file2, 'new');
+        const result = await findLatestVideo(testDir);
+        expect(result).toBe(file2);
+    });
+    it('skips broken symlinks and returns valid file', async () => {
+        const validFile = path.join(testDir, 'valid.mp4');
+        const brokenLink = path.join(testDir, 'broken.mov');
+        await writeFile(validFile, 'content');
+        await symlink('/nonexistent/path.mp4', brokenLink);
+        const result = await findLatestVideo(testDir);
+        expect(result).toBe(validFile);
+    });
+    it('skips files with permission denied and returns valid file', async () => {
+        const readable = path.join(testDir, 'readable.mp4');
+        const unreadable = path.join(testDir, 'unreadable.mov');
+        await writeFile(readable, 'content');
+        await writeFile(unreadable, 'content');
+        await chmod(unreadable, 0o000);
+        const result = await findLatestVideo(testDir);
+        expect(result).toBe(readable);
+    });
+    it('throws when no video files exist', async () => {
+        await writeFile(path.join(testDir, 'file.txt'), 'not a video');
+        await expect(findLatestVideo(testDir)).rejects.toThrow('No video files found');
+    });
+    it('throws when all video files are inaccessible', async () => {
+        const broken = path.join(testDir, 'broken.mov');
+        await symlink('/nonexistent', broken);
+        await chmod(testDir, 0o111);
+        try {
+            await expect(findLatestVideo(testDir)).rejects.toThrow();
+        }
+        finally {
+            await chmod(testDir, 0o755);
+        }
+    });
+    it('expands ~ to home directory', () => {
+        const result = expandPath('~/Videos/test.mp4');
+        expect(result).toMatch(/\/Videos\/test\.mp4$/);
+        expect(result).not.toContain('~');
+    });
+    it('handles various video extensions', async () => {
+        const files = ['a.mov', 'b.mp4', 'c.mkv', 'd.avi', 'e.webm'];
+        for (const f of files) {
+            await writeFile(path.join(testDir, f), 'content');
+        }
+        const result = await findLatestVideo(testDir);
+        expect(result).toMatch(/\.(mov|mp4|mkv|avi|webm)$/);
+    });
+});

package/dist/tests/intelligence.mlx.adapter.test.js

@@ -0,0 +1,222 @@
+/**
+ * MLX Intelligence Adapter Tests
+ *
+ * Tests for Python path detection and auto-venv setup logic used to locate
+ * (or create) the correct Python interpreter with mlx-vlm installed.
+ */
+import { homedir } from 'node:os';
+import { resolve } from 'node:path';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+// Mock node:fs so we can control which paths "exist"
+vi.mock('node:fs', () => ({
+    existsSync: vi.fn(() => false),
+    mkdirSync: vi.fn(),
+    unlinkSync: vi.fn(),
+}));
+// Mock node:child_process so we don't actually spawn anything
+vi.mock('node:child_process', () => ({
+    spawn: vi.fn(() => ({
+        on: vi.fn(),
+        stdout: { on: vi.fn() },
+        stderr: { on: vi.fn() },
+        kill: vi.fn(),
+    })),
+}));
+import { existsSync } from 'node:fs';
+import { resolvePythonPath } from '../adapters/intelligence.mlx.adapter.js';
+import { getPythonPath } from '../python-utils.js';
+const mockExistsSync = vi.mocked(existsSync);
+// Keys cleared/restored around each test
+const MANAGED_KEYS = [
+    'ESCRIBANO_PYTHON_PATH',
+    'VIRTUAL_ENV',
+    'UV_PROJECT_ENVIRONMENT',
+];
+describe('getPythonPath', () => {
+    const saved = {};
+    beforeEach(() => {
+        for (const key of MANAGED_KEYS) {
+            saved[key] = process.env[key];
+            delete process.env[key];
+        }
+        mockExistsSync.mockReturnValue(false);
+    });
+    afterEach(() => {
+        for (const key of MANAGED_KEYS) {
+            if (saved[key] === undefined) {
+                delete process.env[key];
+            }
+            else {
+                process.env[key] = saved[key];
+            }
+        }
+    });
+    it('returns ESCRIBANO_PYTHON_PATH when set (highest priority)', () => {
+        process.env.ESCRIBANO_PYTHON_PATH = '/custom/python3';
+        expect(getPythonPath()).toBe('/custom/python3');
+    });
+    it('returns VIRTUAL_ENV python when set', () => {
+        process.env.VIRTUAL_ENV = '/home/user/myenv';
+        expect(getPythonPath()).toBe(resolve('/home/user/myenv', 'bin', 'python3'));
+    });
+    it('prefers ESCRIBANO_PYTHON_PATH over VIRTUAL_ENV', () => {
+        process.env.ESCRIBANO_PYTHON_PATH = '/explicit/python3';
+        process.env.VIRTUAL_ENV = '/some/venv';
+        expect(getPythonPath()).toBe('/explicit/python3');
+    });
+    it('returns UV_PROJECT_ENVIRONMENT python when set', () => {
+        process.env.UV_PROJECT_ENVIRONMENT = '/project/.venv';
+        expect(getPythonPath()).toBe(resolve('/project/.venv', 'bin', 'python3'));
+    });
+    it('prefers VIRTUAL_ENV over UV_PROJECT_ENVIRONMENT', () => {
+        process.env.VIRTUAL_ENV = '/active/venv';
+        process.env.UV_PROJECT_ENVIRONMENT = '/project/.venv';
+        expect(getPythonPath()).toBe(resolve('/active/venv', 'bin', 'python3'));
+    });
+    it('returns project-local .venv python when it exists', () => {
+        const localVenvPython = resolve(process.cwd(), '.venv', 'bin', 'python3');
+        mockExistsSync.mockImplementation((p) => p === localVenvPython);
+        expect(getPythonPath()).toBe(localVenvPython);
+    });
+    it('returns home .venv python when it exists and local .venv does not', () => {
+        const homeVenvPython = resolve(homedir(), '.venv', 'bin', 'python3');
+        mockExistsSync.mockImplementation((p) => p === homeVenvPython);
+        expect(getPythonPath()).toBe(homeVenvPython);
+    });
+    it('prefers local .venv over home .venv', () => {
+        const localVenvPython = resolve(process.cwd(), '.venv', 'bin', 'python3');
+        const homeVenvPython = resolve(homedir(), '.venv', 'bin', 'python3');
+        mockExistsSync.mockImplementation((p) => p === localVenvPython || p === homeVenvPython);
+        expect(getPythonPath()).toBe(localVenvPython);
+    });
+    it('returns null when nothing is explicitly configured (triggers auto-venv)', () => {
+        mockExistsSync.mockReturnValue(false);
+        expect(getPythonPath()).toBeNull();
+    });
+});
+describe('resolvePythonPath', () => {
+    const saved = {};
+    beforeEach(() => {
+        for (const key of MANAGED_KEYS) {
+            saved[key] = process.env[key];
+            delete process.env[key];
+        }
+        mockExistsSync.mockReturnValue(false);
+    });
+    afterEach(() => {
+        for (const key of MANAGED_KEYS) {
+            if (saved[key] === undefined) {
+                delete process.env[key];
+            }
+            else {
+                process.env[key] = saved[key];
+            }
+        }
+        vi.restoreAllMocks();
+    });
+    it('returns the explicit path immediately when ESCRIBANO_PYTHON_PATH is set', async () => {
+        process.env.ESCRIBANO_PYTHON_PATH = '/my/python3';
+        await expect(resolvePythonPath()).resolves.toBe('/my/python3');
+    });
+    it('returns the explicit path immediately when VIRTUAL_ENV is set', async () => {
+        process.env.VIRTUAL_ENV = '/my/venv';
+        await expect(resolvePythonPath()).resolves.toBe(resolve('/my/venv', 'bin', 'python3'));
+    });
+    it('falls through to managed venv python when nothing is configured', async () => {
+        // Simulate: no explicit config, venv already exists, mlx-vlm already installed
+        const venvPython = resolve(homedir(), '.escribano', 'venv', 'bin', 'python3');
+        mockExistsSync.mockImplementation((p) => p === venvPython);
+        // Mock spawn so the mlx-vlm probe exits with 0 (already installed)
+        const { spawn } = await import('node:child_process');
+        const mockSpawn = vi.mocked(spawn);
+        mockSpawn.mockImplementation((_cmd, _args, _opts) => {
+            const emitter = {
+                on: vi.fn((event, cb) => {
+                    if (event === 'exit')
+                        cb(0);
+                    return emitter;
+                }),
+                stdout: { on: vi.fn() },
+                stderr: { on: vi.fn() },
+                kill: vi.fn(),
+            };
+            return emitter;
+        });
+        await expect(resolvePythonPath()).resolves.toBe(venvPython);
+    });
+    it('creates the managed venv when it does not exist', async () => {
+        // beforeEach has mockExistsSync default to false, simulating a missing venv
+        const venvDir = resolve(homedir(), '.escribano', 'venv');
+        const { spawn } = await import('node:child_process');
+        const mockSpawn = vi.mocked(spawn);
+        mockSpawn.mockClear();
+        // Set up spawn to call exit(0) for all calls so the async function resolves.
+        mockSpawn.mockImplementation((_cmd, _args, _opts) => {
+            const emitter = {
+                on: vi.fn((event, cb) => {
+                    if (event === 'exit')
+                        cb(0);
+                    return emitter;
+                }),
+                stdout: { on: vi.fn() },
+                stderr: { on: vi.fn() },
+                kill: vi.fn(),
+            };
+            return emitter;
+        });
+        await resolvePythonPath();
+        // Expect that we attempted to create a virtual environment in the managed directory
+        expect(mockSpawn).toHaveBeenCalled();
+        // Find the venv-creation call: command is python3 with -m venv <dir>
+        const venvCall = mockSpawn.mock.calls.find(([cmd, args]) => typeof cmd === 'string' &&
+            (cmd === 'python3' || cmd === 'python') &&
+            Array.isArray(args) &&
+            args.includes('-m') &&
+            args.includes('venv'));
+        expect(venvCall).toBeDefined();
+        expect(venvCall?.[1]).toContain(venvDir);
+    });
+    it('installs mlx-vlm when the import probe fails', async () => {
+        const venvPython = resolve(homedir(), '.escribano', 'venv', 'bin', 'python3');
+        // Simulate: managed venv python exists
+        mockExistsSync.mockImplementation((p) => p === venvPython);
+        const { spawn } = await import('node:child_process');
+        const mockSpawn = vi.mocked(spawn);
+        mockSpawn.mockClear();
+        let callIndex = 0;
+        mockSpawn.mockImplementation((_cmd, _args, _opts) => {
+            const thisCall = callIndex++;
+            const emitter = {
+                on: vi.fn((event, cb) => {
+                    if (event === 'exit') {
+                        // First call: import probe fails (non-zero exit)
+                        // All subsequent calls (ensurepip, pip install, ...): succeed
+                        cb(thisCall === 0 ? 1 : 0);
+                    }
+                    return emitter;
+                }),
+                stdout: { on: vi.fn() },
+                stderr: { on: vi.fn() },
+                kill: vi.fn(),
+            };
+            return emitter;
+        });
+        await expect(resolvePythonPath()).resolves.toBe(venvPython);
+        expect(mockSpawn.mock.calls.length).toBeGreaterThanOrEqual(2);
+        // Find the pip install call regardless of its position (robust to ensurepip being inserted)
+        const installCall = mockSpawn.mock.calls.find(([_cmd, args]) => Array.isArray(args) &&
+            args.includes('-m') &&
+            args.includes('pip') &&
+            args.includes('install') &&
+            args.includes('mlx-vlm'));
+        expect(installCall).toBeDefined();
+        expect(installCall?.[1]).toEqual(expect.arrayContaining([
+            '-m',
+            'pip',
+            'install',
+            'mlx-vlm',
+            'torch',
+            'torchvision',
+        ]));
+    });
+});

package/dist/tests/intelligence.ollama.adapter.test.js

@@ -1,3 +1,4 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
 /**
  * Intelligence Adapter Tests
  */

package/dist/tests/services/clustering.test.js

@@ -1,3 +1,4 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
 import { describe, expect, it, vi } from 'vitest';
 import { embeddingToBlob } from '../../db/helpers.js';
 import { clusterObservations } from '../../services/clustering.js';

package/dist/tests/services/frame-sampling.test.js

@@ -126,7 +126,7 @@ describe('adaptiveSampleWithScenes', () => {
     it('should produce fewer total frames with high scene density', () => {
         const frames = makeFrames(10); // 10 minutes, 300 frames
         // Low density: 5 scene changes
-        const lowDensityResult = adaptiveSampleWithScenes(frames, [30, 100, 200, 400, 500], { baseIntervalSeconds: 10 });
+        const _lowDensityResult = adaptiveSampleWithScenes(frames, [30, 100, 200, 400, 500], { baseIntervalSeconds: 10 });
         // High density: 60 scene changes (every ~10s)
         const highDensityScenes = Array.from({ length: 60 }, (_, i) => i * 10);
         const highDensityResult = adaptiveSampleWithScenes(frames, highDensityScenes, { baseIntervalSeconds: 10 });

package/dist/tests/visual-observer.test.js

@@ -150,7 +150,6 @@ describe('Visual Observer Pipeline', () => {
             transcribeSegment: vi.fn().mockResolvedValue(''),
         };
         const mockVideoService = {
-            // biome-ignore lint/suspicious/noExplicitAny: mock
             ...vi.fn(), // Other methods mocked as needed
             extractFramesAtTimestamps: vi.fn(),
             extractFramesAtInterval: vi

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "escribano",
-  "version": "0.2.2",
+  "version": "0.4.1",
   "description": "AI-powered session intelligence tool — turn screen recordings into structured work summaries",
   "main": "dist/index.js",
   "type": "module",
@@ -66,6 +66,7 @@
   },
   "dependencies": {
     "better-sqlite3": "^12.6.2",
+    "dotenv": "^17.3.1",
     "express": "^5.0.0",
     "pidusage": "^4.0.1",
     "undici": "^7.22.0",

package/scripts/create-release.mjs

@@ -15,14 +15,40 @@ function getCurrentTag() {
   try {
     return run("git describe --tags --exact-match");
   } catch {
-    console.error("❌ No git tag found at current commit");
-    console.error("   Run: git tag v<x.y.z> && git push --tags");
-    process.exit(1);
+    // No tag - create one from package.json
+    const pkg = JSON.parse(readFileSync(join(REPO_ROOT, "package.json")));
+    const tag = `v${pkg.version}`;
+    
+    console.log(`⚠️  No tag found, creating ${tag}...`);
+    run(`git tag ${tag}`);
+    run(`git push origin ${tag}`);
+    console.log(`✅ Created and pushed tag: ${tag}`);
+    
+    return tag;
   }
 }
 
 function getPreviousTag(currentTag) {
-  const allTags = run("git tag --list 'v*' | sort -V").split("\n").filter(Boolean);
+  // Fetch latest tags from remote
+  run("git fetch origin --tags");
+  
+  // Get all version tags and sort them
+  const allTagsOutput = run("git tag --list 'v*'");
+  const allTags = allTagsOutput.split("\n").filter(Boolean);
+  
+  // Sort by version number
+  allTags.sort((a, b) => {
+    const aVersion = a.replace(/^v/, "").split(".").map(Number);
+    const bVersion = b.replace(/^v/, "").split(".").map(Number);
+    
+    for (let i = 0; i < Math.max(aVersion.length, bVersion.length); i++) {
+      const aPart = aVersion[i] || 0;
+      const bPart = bVersion[i] || 0;
+      if (aPart !== bPart) return aPart - bPart;
+    }
+    return 0;
+  });
+  
   const currentIndex = allTags.indexOf(currentTag);
   
   if (currentIndex === 0) return null;
@@ -161,6 +187,29 @@ function createGitHubRelease(tag, releaseNotes) {
   }
 }
 
+function commitAndPushChangelog(tag) {
+  try {
+    // Check if there are changes
+    const status = run("git status --porcelain CHANGELOG.md");
+    
+    if (!status) {
+      console.log("ℹ️  CHANGELOG.md already up to date, nothing to commit");
+      return;
+    }
+    
+    // Stage, commit, and push
+    run("git add CHANGELOG.md");
+    run(`git commit -m "docs: update CHANGELOG for ${tag}"`);
+    run("git push");
+    
+    console.log(`✅ Committed and pushed CHANGELOG.md for ${tag}`);
+  } catch (error) {
+    console.error("⚠️  Failed to commit/push CHANGELOG.md:", error.message);
+    console.error("   You may need to commit manually:");
+    console.error("   git add CHANGELOG.md && git commit -m 'docs: update CHANGELOG' && git push");
+  }
+}
+
 async function main() {
   console.log("🚀 Creating GitHub release...\n");
   
@@ -187,12 +236,9 @@ async function main() {
   
   updateChangelog(releaseNotes);
   createGitHubRelease(currentTag, releaseNotes);
+  commitAndPushChangelog(currentTag);
   
-  console.log("\n🎉 Release complete!");
-  console.log("\nNext steps:");
-  console.log("  1. Review CHANGELOG.md changes");
-  console.log("  2. Commit: git add CHANGELOG.md && git commit -m 'docs: update CHANGELOG'");
-  console.log("  3. Push: git push");
+  console.log("\n🎉 Release complete! All changes pushed to GitHub.");
 }
 
 main().catch(error => {

package/scripts/mlx_bridge.py

@@ -133,7 +133,7 @@ def signal_handler(signum: int, frame: Any) -> None:
 def load_model() -> tuple[Any, Any, Any]:
     """Load MLX-VLM model."""
     log(f"Loading model: {MODEL_NAME}")
-    log("This may take 30-60 seconds on first run or after memory clear...")
+    log("This may take 30-120 seconds on first run or after memory clear...")
     start = time.time()
 
     try:
@@ -153,7 +153,31 @@ def load_model() -> tuple[Any, Any, Any]:
         return model_obj, processor_obj, config_obj
     except ImportError as e:
         log(f"Failed to import mlx_vlm: {e}", "error")
-        log("Install with: pip install mlx-vlm", "error")
+        log(f"Python used: {sys.executable}", "error")
+        custom_python = os.environ.get("ESCRIBANO_PYTHON_PATH")
+        if custom_python:
+            log(
+                "ESCRIBANO_PYTHON_PATH is set, so Escribano does not auto-install mlx-vlm "
+                "into this Python environment.",
+                "error",
+            )
+            log(
+                f"Make sure mlx-vlm is installed for that Python "
+                f"(e.g. `{custom_python} -m pip install mlx-vlm`), "
+                "or unset ESCRIBANO_PYTHON_PATH to let Escribano manage its own Python.",
+                "error",
+            )
+        else:
+            log(
+                "mlx-vlm is missing from Escribano's managed Python environment. "
+                "It is normally installed automatically.",
+                "error",
+            )
+            log(
+                "Try restarting Escribano so it can recreate or repair its Python environment. "
+                "If the problem persists, install `mlx-vlm` into this Python or report an issue.",
+                "error",
+            )
         sys.exit(1)
     except Exception as e:
         log(f"Failed to load model: {e}", "error")