@sushanglewis/lincoln 1.5.0 → 1.5.2

package/framework/tools/lincoln-record/tests/cli_args.rs

@@ -0,0 +1,103 @@
+use std::path::PathBuf;
+
+use clap::Parser;
+use lincoln_record::cli::Cli;
+
+#[test]
+fn test_cli_parses_record_command() {
+    let cli = Cli::try_parse_from([
+        "lincoln-record",
+        "record",
+        "--session-id",
+        "2026-07-09-recording-replacement",
+        "--mic",
+        "MacBook Pro Microphone",
+        "--system-auto",
+        "--engine",
+        "whisper",
+        "--model",
+        "large-v3-turbo",
+        "--diarize",
+        "--output",
+        "/tmp/interviews",
+        "--language",
+        "zh",
+    ])
+    .expect("record args should parse");
+
+    match cli {
+        Cli::Record(args) => {
+            assert_eq!(args.session_id, "2026-07-09-recording-replacement");
+            assert_eq!(args.mic, Some("MacBook Pro Microphone".to_string()));
+            assert!(args.system_auto);
+            assert_eq!(args.engine, "whisper");
+            assert_eq!(args.model, Some("large-v3-turbo".to_string()));
+            assert!(args.diarize);
+            assert_eq!(args.output, Some(PathBuf::from("/tmp/interviews")));
+            assert_eq!(args.language, Some("zh".to_string()));
+        }
+        other => panic!("expected Record command, got {:?}", other),
+    }
+}
+
+#[test]
+fn test_cli_parses_transcribe_command() {
+    let cli = Cli::try_parse_from([
+        "lincoln-record",
+        "transcribe",
+        "/tmp/sample.wav",
+        "--session-id",
+        "test-session",
+        "--diarize",
+    ])
+    .expect("transcribe args should parse");
+
+    match cli {
+        Cli::Transcribe(args) => {
+            assert_eq!(args.path, PathBuf::from("/tmp/sample.wav"));
+            assert_eq!(args.session_id, Some("test-session".to_string()));
+            assert!(args.diarize);
+            assert!(!args.engine.is_empty());
+        }
+        other => panic!("expected Transcribe command, got {:?}", other),
+    }
+}
+
+#[test]
+fn test_cli_parses_devices_command() {
+    let cli = Cli::try_parse_from(["lincoln-record", "devices"]).expect("devices should parse");
+    assert!(matches!(cli, Cli::Devices));
+}
+
+#[test]
+fn test_cli_parses_warmup_command() {
+    let cli = Cli::try_parse_from([
+        "lincoln-record",
+        "warmup",
+        "--model",
+        "base",
+        "--engine",
+        "whisper",
+        "--cache-dir",
+        "/tmp/cache",
+    ])
+    .expect("warmup args should parse");
+
+    match cli {
+        Cli::Warmup(args) => {
+            assert_eq!(args.model, Some("base".to_string()));
+            assert_eq!(args.engine, Some("whisper".to_string()));
+            assert_eq!(args.cache_dir, Some(PathBuf::from("/tmp/cache")));
+        }
+        other => panic!("expected Warmup command, got {:?}", other),
+    }
+}
+
+#[test]
+fn test_cli_record_requires_session_id() {
+    let result = Cli::try_parse_from(["lincoln-record", "record"]);
+    assert!(
+        result.is_err(),
+        "record command should require --session-id"
+    );
+}

package/framework/tools/lincoln-record/tests/config_test.rs

@@ -0,0 +1,70 @@
+use lincoln_record::config::Config;
+use std::io::Write;
+
+#[test]
+fn test_config_defaults() {
+    let config = Config::default();
+    assert_eq!(config.audio.sample_rate, 48000);
+    assert_eq!(config.audio.channels, 2);
+    assert_eq!(config.transcription.engine, "whisper");
+    assert_eq!(config.transcription.model, "large-v3");
+    assert_eq!(config.transcription.language, "auto");
+    assert!(!config.diarization.enabled);
+    assert_eq!(config.diarization.hf_token, "");
+    assert_eq!(config.output.format, "markdown");
+    assert!(config.output.keep_recording);
+}
+
+#[test]
+fn test_config_loads_from_toml_file() {
+    let mut tmp = tempfile::NamedTempFile::new().expect("temp file");
+    write!(
+        tmp,
+        r#"
+[audio]
+sample_rate = 16000
+channels = 1
+
+[transcription]
+engine = "parakeet"
+model = "parakeet-tiny"
+language = "zh"
+
+[diarization]
+enabled = true
+hf_token = "hf_xxx"
+
+[output]
+format = "json"
+keep_recording = false
+"#
+    )
+    .expect("write config");
+
+    let config = Config::load_from_path(tmp.path()).expect("load config");
+    assert_eq!(config.audio.sample_rate, 16000);
+    assert_eq!(config.audio.channels, 1);
+    assert_eq!(config.transcription.engine, "parakeet");
+    assert_eq!(config.transcription.model, "parakeet-tiny");
+    assert_eq!(config.transcription.language, "zh");
+    assert!(config.diarization.enabled);
+    assert_eq!(config.diarization.hf_token, "hf_xxx");
+    assert_eq!(config.output.format, "json");
+    assert!(!config.output.keep_recording);
+}
+
+#[test]
+fn test_config_load_missing_file_falls_back_to_defaults() {
+    let config = Config::load_from_path(std::path::Path::new("/nonexistent/lincoln-record.toml"))
+        .expect("missing file should fall back to defaults");
+    assert_eq!(config.audio.sample_rate, 48000);
+    assert_eq!(config.output.format, "markdown");
+}
+
+#[test]
+fn test_config_rejects_invalid_toml() {
+    let mut tmp = tempfile::NamedTempFile::new().expect("temp file");
+    write!(tmp, "not valid toml [[[").expect("write invalid config");
+    let result = Config::load_from_path(tmp.path());
+    assert!(result.is_err(), "invalid TOML should error");
+}

package/framework/tools/lincoln-record/tests/devices_test.rs

@@ -0,0 +1,23 @@
+use lincoln_record::audio::devices::{default_input_device, list_input_devices};
+
+#[test]
+fn test_list_input_devices_returns_vec() {
+    let devices = list_input_devices().expect("cpal should enumerate input devices");
+    assert!(
+        !devices.is_empty(),
+        "cpal should report at least one input device on this machine"
+    );
+    for name in &devices {
+        assert!(!name.is_empty(), "device name should not be empty");
+    }
+}
+
+#[test]
+fn test_default_input_device_has_name() {
+    let device = default_input_device();
+    assert!(device.is_some(), "there should be a default input device");
+    assert!(
+        !device.unwrap().is_empty(),
+        "default device name should not be empty"
+    );
+}

package/framework/tools/lincoln-record/tests/diarization_tests.rs

@@ -0,0 +1,101 @@
+use lincoln_record::audio::saver::write_source_to_wav;
+use lincoln_record::audio::source::{AudioSource, SineWaveSource};
+use std::path::PathBuf;
+use std::process::Command;
+use tempfile::TempDir;
+
+fn generate_two_speaker_fixture(path: &std::path::Path) {
+    let speaker_a = SineWaveSource::new(48000.0, 1, 440.0, 1.0).expect("valid source");
+    let speaker_b = SineWaveSource::new(48000.0, 1, 880.0, 1.0).expect("valid source");
+
+    // Concatenate one second of speaker A followed by one second of speaker B.
+    let samples: Vec<f32> = speaker_a
+        .iter()
+        .take(48000)
+        .chain(speaker_b.iter().take(48000))
+        .collect();
+
+    let combined = lincoln_record::audio::source::InMemorySource::new(samples, 48000, 1, 2.0);
+    write_source_to_wav(&combined, path, 48000, 1).expect("write fixture");
+}
+
+#[test]
+fn test_diarize_labels_two_speakers() {
+    let tmp = TempDir::new().expect("temp dir");
+    let fixture = tmp.path().join("two_speakers.wav");
+    generate_two_speaker_fixture(&fixture);
+
+    let project_root = PathBuf::from(env!("CARGO_MANIFEST_DIR"));
+    let script = project_root.join("diarize/diarize.py");
+
+    let output = Command::new("python3")
+        .arg(&script)
+        .arg(&fixture)
+        .arg("--output")
+        .arg(tmp.path().join("diarization.json"))
+        .output()
+        .expect("run diarize.py");
+
+    assert!(
+        output.status.success(),
+        "diarize.py failed: {}",
+        String::from_utf8_lossy(&output.stderr)
+    );
+
+    let raw = std::fs::read_to_string(tmp.path().join("diarization.json")).expect("read output");
+    let diarization: serde_json::Value = serde_json::from_str(&raw).expect("parse json");
+    let speakers = diarization
+        .as_array()
+        .expect("diarization is array")
+        .iter()
+        .map(|entry| entry["speaker"].as_str().unwrap_or(""))
+        .collect::<std::collections::HashSet<_>>();
+    assert_eq!(
+        speakers.len(),
+        2,
+        "fixture should contain two distinct speakers"
+    );
+}
+
+#[test]
+fn test_merge_combines_diarization_with_transcript() {
+    let tmp = TempDir::new().expect("temp dir");
+    let project_root = PathBuf::from(env!("CARGO_MANIFEST_DIR"));
+    let script = project_root.join("diarize/merge.py");
+
+    let transcript = serde_json::json!([
+        {"start": 0.0, "end": 1.0, "text": "hello"},
+        {"start": 1.0, "end": 2.0, "text": "world"}
+    ]);
+    let diarization = serde_json::json!([
+        {"start": 0.0, "end": 1.0, "speaker": "A"},
+        {"start": 1.0, "end": 2.0, "speaker": "B"}
+    ]);
+
+    std::fs::write(tmp.path().join("transcript.json"), transcript.to_string())
+        .expect("write transcript");
+    std::fs::write(tmp.path().join("diarization.json"), diarization.to_string())
+        .expect("write diarization");
+
+    let output = Command::new("python3")
+        .arg(&script)
+        .arg(tmp.path().join("transcript.json"))
+        .arg(tmp.path().join("diarization.json"))
+        .arg("--output")
+        .arg(tmp.path().join("merged.json"))
+        .output()
+        .expect("run merge.py");
+
+    assert!(
+        output.status.success(),
+        "merge.py failed: {}",
+        String::from_utf8_lossy(&output.stderr)
+    );
+
+    let raw = std::fs::read_to_string(tmp.path().join("merged.json")).expect("read output");
+    let merged: serde_json::Value = serde_json::from_str(&raw).expect("parse json");
+    let first = &merged.as_array().unwrap()[0];
+    assert_eq!(first["speaker"], "A");
+    let second = &merged.as_array().unwrap()[1];
+    assert_eq!(second["speaker"], "B");
+}

package/framework/tools/lincoln-record/tests/integration_tests.rs

@@ -0,0 +1,44 @@
+use hound::WavReader;
+use lincoln_record::audio::saver::write_source_to_wav;
+use lincoln_record::audio::source::{AudioSource, SineWaveSource};
+use tempfile::TempDir;
+
+#[test]
+fn test_synthetic_source_writes_wav_file() {
+    let tmp = TempDir::new().expect("temp dir");
+    let output = tmp.path().join("sine.wav");
+
+    let source = SineWaveSource::new(48000.0, 1, 1000.0, 1.0).expect("valid source");
+    write_source_to_wav(&source, &output, 48000, 1).expect("write wav");
+
+    assert!(output.exists(), "output wav file should exist");
+    let reader = WavReader::open(&output).expect("open wav");
+    let spec = reader.spec();
+    assert_eq!(spec.sample_rate, 48000);
+    assert_eq!(spec.channels, 1);
+    let samples: Vec<i32> = reader
+        .into_samples::<i32>()
+        .filter_map(Result::ok)
+        .collect();
+    assert_eq!(
+        samples.len(),
+        48000,
+        "one second of 48 kHz mono should have 48000 samples"
+    );
+}
+
+#[test]
+fn test_resample_changes_sample_rate() {
+    let input: Vec<f32> = SineWaveSource::new(16000.0, 1, 440.0, 1.0)
+        .expect("valid source")
+        .iter()
+        .take(16000)
+        .collect();
+    let resampled = lincoln_record::audio::resampler::resample_interleaved(&input, 16000, 48000, 1)
+        .expect("resample");
+    assert_eq!(
+        resampled.len(),
+        48000,
+        "16000 mono samples resampled to 48000 should produce 48000"
+    );
+}

package/framework/tools/lincoln-record/tests/model_test.rs

@@ -0,0 +1,68 @@
+use lincoln_record::config::Config;
+use lincoln_record::model::resolve_model_path;
+use std::path::PathBuf;
+
+#[test]
+fn test_config_loads_model_cache_dir() {
+    let config: Config = toml::from_str(
+        r#"
+model_cache_dir = "/custom/cache"
+[transcription]
+engine = "whisper"
+model = "small"
+"#,
+    )
+    .unwrap();
+    assert_eq!(
+        config.model_cache_dir,
+        Some(PathBuf::from("/custom/cache"))
+    );
+    assert_eq!(config.transcription.model, "small");
+}
+
+#[test]
+fn test_resolve_model_path_uses_absolute_cli_path() {
+    let config = Config::default();
+    let path = PathBuf::from("/absolute/ggml-custom.bin");
+    let resolved = resolve_model_path(Some(&path), &config).unwrap();
+    assert_eq!(resolved, path);
+}
+
+#[test]
+fn test_resolve_model_path_uses_name_from_config() {
+    let mut config = Config::default();
+    config.model_cache_dir = Some(PathBuf::from("/cache"));
+    config.transcription.model = "tiny".to_string();
+
+    let resolved = resolve_model_path(None, &config).unwrap();
+    assert_eq!(
+        resolved,
+        PathBuf::from("/cache/whisper/ggml-tiny.bin")
+    );
+}
+
+#[test]
+fn test_resolve_model_path_cli_name_overrides_config() {
+    let mut config = Config::default();
+    config.model_cache_dir = Some(PathBuf::from("/cache"));
+    config.transcription.model = "large".to_string();
+
+    let resolved = resolve_model_path(Some(PathBuf::from("base").as_path()), &config).unwrap();
+    assert_eq!(
+        resolved,
+        PathBuf::from("/cache/whisper/ggml-base.bin")
+    );
+}
+
+#[test]
+fn test_resolve_model_path_missing_returns_error_with_url() {
+    let mut config = Config::default();
+    config.model_cache_dir = Some(PathBuf::from("/cache"));
+    config.transcription.model = "missing-model".to_string();
+
+    let err = resolve_model_path(None, &config).unwrap_err();
+    let msg = format!("{}", err);
+    assert!(msg.contains("missing-model"));
+    assert!(msg.contains("huggingface"));
+    assert!(msg.contains("lincoln-record warmup"));
+}

package/framework/tools/lincoln-record/tests/transcription_tests.rs

@@ -0,0 +1,73 @@
+use lincoln_record::output::metadata::{DeviceInfo, FileInfo, SessionMetadata};
+use lincoln_record::output::transcript::{TranscriptSegment, format_transcript};
+use lincoln_record::transcription::provider::{MockProvider, TranscriptionProvider};
+use std::path::PathBuf;
+
+#[test]
+fn test_mock_provider_returns_segments() {
+    let provider = MockProvider::new(vec![TranscriptSegment {
+        start: 0.0,
+        end: 2.0,
+        speaker: Some("Speaker 1".to_string()),
+        text: "Hello world".to_string(),
+    }]);
+
+    let segments = provider
+        .transcribe(&PathBuf::from("/tmp/sample.wav"), Some("en"))
+        .expect("mock provider should always succeed");
+
+    assert_eq!(segments.len(), 1);
+    assert_eq!(segments[0].text, "Hello world");
+}
+
+#[test]
+fn test_transcript_formatting_includes_session_and_speakers() {
+    let segments = vec![
+        TranscriptSegment {
+            start: 0.0,
+            end: 2.0,
+            speaker: Some("Speaker 1".to_string()),
+            text: "Hello".to_string(),
+        },
+        TranscriptSegment {
+            start: 2.5,
+            end: 4.0,
+            speaker: Some("Speaker 2".to_string()),
+            text: "Hi there".to_string(),
+        },
+    ];
+
+    let markdown = format_transcript("2026-07-11-test", &segments);
+    assert!(markdown.contains("# Interview: 2026-07-11-test"));
+    assert!(markdown.contains("- Speaker 1"));
+    assert!(markdown.contains("- Speaker 2"));
+    assert!(markdown.contains("**[00:00:00] Speaker 1**: Hello"));
+    assert!(markdown.contains("**[00:00:02] Speaker 2**: Hi there"));
+}
+
+#[test]
+fn test_metadata_serializes_required_fields() {
+    let metadata = SessionMetadata {
+        session_id: "2026-07-11-test".to_string(),
+        process_slug: "issue-25".to_string(),
+        started_at: "2026-07-11T10:00:00Z".to_string(),
+        ended_at: Some("2026-07-11T10:30:00Z".to_string()),
+        engine: "whisper".to_string(),
+        model: "large-v3-turbo".to_string(),
+        diarization: false,
+        devices: DeviceInfo {
+            microphone: "MacBook Pro Microphone".to_string(),
+            system: None,
+        },
+        files: FileInfo {
+            transcript: "transcript.md".to_string(),
+            audio: "audio.wav".to_string(),
+            metadata: "metadata.json".to_string(),
+        },
+    };
+
+    let json = serde_json::to_string_pretty(&metadata).expect("serialize");
+    assert!(json.contains("2026-07-11-test"));
+    assert!(json.contains("issue-25"));
+    assert!(json.contains("large-v3-turbo"));
+}

package/package.json

@@ -1,16 +1,19 @@
 {
   "name": "@sushanglewis/lincoln",
-  "version": "1.5.0",
-  "description": "Cross-tool terminal UI for recording Lincoln interviews",
+  "version": "1.5.2",
+  "description": "Global Lincoln agent harness plugin CLI",
   "type": "module",
   "main": "./dist/index.js",
   "module": "./dist/index.js",
   "types": "./dist/index.d.ts",
   "bin": {
-    "lincoln": "./dist/main.js"
+    "lincoln": "./dist/main.js",
+    "lincoln-install": "./dist/main.js",
+    "lincoln-update": "./dist/main.js"
   },
   "files": [
-    "dist"
+    "dist",
+    "framework"
   ],
   "scripts": {
     "build": "tsup",
@@ -19,18 +22,19 @@
     "test:watch": "vitest",
     "typecheck": "tsc --noEmit",
     "typecheck:tests": "tsc -p tsconfig.tests.json",
-    "lint": "echo 'lint not configured'"
+    "lint": "echo 'lint not configured'",
+    "prepack": "npm run build && node ../../scripts/sync-framework-package.mjs",
+    "postinstall": "node dist/postinstall.js"
   },
   "dependencies": {
-    "ink": "^5.2.0",
-    "js-yaml": "^4.1.0",
-    "react": "^18.3.1"
+    "js-yaml": "^4.1.0"
+  },
+  "optionalDependencies": {
+    "@sushanglewis/lincoln-recorder": "^1.5.0"
   },
   "devDependencies": {
     "@types/js-yaml": "^4.0.9",
     "@types/node": "^22.15.0",
-    "@types/react": "^18.3.12",
-    "ink-testing-library": "^4.0.0",
     "tsup": "^8.5.0",
     "typescript": "^5.8.3",
     "vitest": "^4.1.9"
@@ -40,9 +44,11 @@
   },
   "keywords": [
     "lincoln",
-    "interview",
-    "recording",
-    "tui"
+    "agent-harness",
+    "claude-code",
+    "codex",
+    "opencode",
+    "plugin"
   ],
   "license": "MIT"
 }