tmux-ide 2.1.4 → 2.6.0

package/src/lib/authorship.test.ts

@@ -1,242 +0,0 @@
-import { describe, it, expect } from "bun:test";
-import {
-  extractMarks,
-  embedMarks,
-  calculateStats,
-  createAuthored,
-  normalizeQuote,
-  reanchorMarks,
-  tagContent,
-  generateMarkId,
-  type Mark,
-  type MarksDocument,
-} from "./authorship.ts";
-
-describe("normalizeQuote", () => {
-  it("collapses whitespace", () => {
-    expect(normalizeQuote("  hello   world  ")).toBe("hello world");
-  });
-
-  it("handles newlines", () => {
-    expect(normalizeQuote("line1\n  line2\n")).toBe("line1 line2");
-  });
-});
-
-describe("generateMarkId", () => {
-  it("returns unique IDs", () => {
-    const a = generateMarkId();
-    const b = generateMarkId();
-    expect(a).not.toBe(b);
-    expect(a.startsWith("m")).toBeTruthy();
-  });
-});
-
-describe("createAuthored", () => {
-  it("creates a mark with correct fields", () => {
-    const mark = createAuthored("ai:François", { from: 0, to: 50 }, "some text");
-    expect(mark.kind).toBe("authored");
-    expect(mark.by).toBe("ai:François");
-    expect(mark.range.from).toBe(0);
-    expect(mark.range.to).toBe(50);
-    expect(mark.quote).toBe("some text");
-    expect(mark.id.startsWith("m")).toBeTruthy();
-    expect(mark.at.includes("T")).toBeTruthy(); // ISO timestamp
-  });
-});
-
-describe("extractMarks", () => {
-  it("extracts marks from markdown with comment block", () => {
-    const doc: MarksDocument = {
-      version: 2,
-      marks: {
-        m1: {
-          id: "m1",
-          kind: "authored",
-          by: "ai:François",
-          at: "2026-01-01T00:00:00Z",
-          range: { from: 0, to: 13 },
-          quote: "Hello world!",
-        },
-      },
-    };
-    const md = `Hello world!\n\n<!-- TMUX-IDE:MARKS\n${JSON.stringify(doc, null, 2)}\n-->\n`;
-
-    const result = extractMarks(md);
-    expect(result.marks).toBeTruthy();
-    expect(result.marks!.version).toBe(2);
-    expect(Object.keys(result.marks!.marks).length).toBe(1);
-    expect(result.marks!.marks["m1"]!.by).toBe("ai:François");
-    expect(result.content.includes("Hello world!")).toBeTruthy();
-    expect(!result.content.includes("TMUX-IDE:MARKS")).toBeTruthy();
-  });
-
-  it("returns null marks when no comment block", () => {
-    const md = "Just content.";
-    const result = extractMarks(md);
-    expect(result.marks).toBe(null);
-    expect(result.content).toBe(md);
-  });
-
-  it("handles malformed JSON gracefully", () => {
-    const md = "Content.\n\n<!-- TMUX-IDE:MARKS\nnot json\n-->\n";
-    const result = extractMarks(md);
-    expect(result.marks).toBe(null);
-  });
-});
-
-describe("embedMarks", () => {
-  it("appends marks comment to markdown", () => {
-    const md = "Hello world!";
-    const doc: MarksDocument = {
-      version: 2,
-      marks: {
-        m1: createAuthored("ai:François", { from: 0, to: 12 }, "Hello world!"),
-      },
-    };
-
-    const result = embedMarks(md, doc);
-    expect(result.includes("Hello world!")).toBeTruthy();
-    expect(result.includes("TMUX-IDE:MARKS")).toBeTruthy();
-    expect(result.includes("ai:François")).toBeTruthy();
-  });
-
-  it("replaces existing marks comment", () => {
-    const oldDoc: MarksDocument = { version: 2, marks: {} };
-    const md = `Content.\n\n<!-- TMUX-IDE:MARKS\n${JSON.stringify(oldDoc)}\n-->\n`;
-
-    const newDoc: MarksDocument = {
-      version: 2,
-      marks: {
-        m1: createAuthored("human:thijs", { from: 0, to: 8 }, "Content."),
-      },
-    };
-
-    const result = embedMarks(md, newDoc);
-    const count = (result.match(/TMUX-IDE:MARKS/g) || []).length;
-    expect(count).toBe(1);
-    expect(result.includes("human:thijs")).toBeTruthy();
-  });
-});
-
-describe("calculateStats", () => {
-  it("calculates AI vs human percentages from marks", () => {
-    const marks: Record<string, Mark> = {
-      m1: createAuthored("ai:François", { from: 0, to: 300 }, "ai text"),
-      m2: createAuthored("human:thijs", { from: 300, to: 500 }, "human text"),
-    };
-    const stats = calculateStats(marks);
-    expect(stats.totalChars).toBe(500);
-    expect(stats.aiPercent).toBe(60);
-    expect(stats.humanPercent).toBe(40);
-  });
-
-  it("returns 100% AI when all marks are AI", () => {
-    const marks: Record<string, Mark> = {
-      m1: createAuthored("ai:Amélie", { from: 0, to: 100 }, "text"),
-      m2: createAuthored("ai:Louis", { from: 100, to: 200 }, "more text"),
-    };
-    const stats = calculateStats(marks);
-    expect(stats.aiPercent).toBe(100);
-    expect(stats.humanPercent).toBe(0);
-  });
-
-  it("returns zeros for empty marks", () => {
-    const stats = calculateStats({});
-    expect(stats.totalChars).toBe(0);
-    expect(stats.aiPercent).toBe(0);
-  });
-
-  it("skips orphaned marks", () => {
-    const marks: Record<string, Mark> = {
-      m1: { ...createAuthored("ai:X", { from: 0, to: 100 }, "text"), orphaned: true },
-      m2: createAuthored("human:Y", { from: 0, to: 50 }, "text"),
-    };
-    const stats = calculateStats(marks);
-    expect(stats.totalChars).toBe(50);
-    expect(stats.humanPercent).toBe(100);
-  });
-
-  it("skips non-authored marks", () => {
-    const marks: Record<string, Mark> = {
-      m1: createAuthored("ai:X", { from: 0, to: 100 }, "text"),
-      m2: { ...createAuthored("human:Y", { from: 0, to: 50 }, "text"), kind: "comment" },
-    };
-    const stats = calculateStats(marks);
-    expect(stats.totalChars).toBe(100);
-    expect(stats.aiPercent).toBe(100);
-  });
-});
-
-describe("reanchorMarks", () => {
-  it("keeps marks with matching quotes at correct positions", () => {
-    const content = "Hello world!";
-    const marks: Record<string, Mark> = {
-      m1: createAuthored("ai:X", { from: 0, to: 12 }, "Hello world!"),
-    };
-    const result = reanchorMarks(content, marks);
-    expect(result["m1"]!.range.from).toBe(0);
-    expect(result["m1"]!.range.to).toBe(12);
-    expect(result["m1"]!.orphaned).toBe(undefined);
-  });
-
-  it("re-anchors marks when content shifts", () => {
-    // Content was "XHello" but now prefix was removed
-    const content = "Hello world!";
-    const marks: Record<string, Mark> = {
-      m1: createAuthored("ai:X", { from: 1, to: 13 }, "Hello world!"),
-    };
-    const result = reanchorMarks(content, marks);
-    expect(result["m1"]!.range.from).toBe(0);
-    expect(result["m1"]!.range.to).toBe(12);
-  });
-
-  it("orphans marks when quote not found", () => {
-    const content = "Completely different text.";
-    const marks: Record<string, Mark> = {
-      m1: createAuthored("ai:X", { from: 0, to: 12 }, "Hello world!"),
-    };
-    const result = reanchorMarks(content, marks);
-    expect(result["m1"]!.orphaned).toBe(true);
-  });
-});
-
-describe("tagContent", () => {
-  it("tags entire content as authored", () => {
-    const md = "Hello world!";
-    const result = tagContent(md, "ai:François");
-
-    const { marks } = extractMarks(result);
-    expect(marks).toBeTruthy();
-    const authored = Object.values(marks!.marks).filter((m) => m.kind === "authored");
-    expect(authored.length > 0).toBeTruthy();
-    expect(authored[0]!.by).toBe("ai:François");
-    expect(authored[0]!.range.from).toBe(0);
-    expect(authored[0]!.range.to).toBe(12);
-  });
-
-  it("preserves existing marks and only tags uncovered ranges", () => {
-    const existingMark = createAuthored("human:thijs", { from: 0, to: 5 }, "Hello");
-    const doc: MarksDocument = { version: 2, marks: { [existingMark.id]: existingMark } };
-    const md = embedMarks("Hello world!", doc);
-
-    const result = tagContent(md, "ai:Amélie");
-    const { marks } = extractMarks(result);
-    expect(marks).toBeTruthy();
-
-    const marksList = Object.values(marks!.marks).filter(
-      (m) => m.kind === "authored" && !m.orphaned,
-    );
-    // Should have human mark for "Hello" and AI mark for the rest
-    const humanMarks = marksList.filter((m) => m.by === "human:thijs");
-    const aiMarks = marksList.filter((m) => m.by === "ai:Amélie");
-    expect(humanMarks.length > 0).toBeTruthy();
-    expect(aiMarks.length > 0).toBeTruthy();
-  });
-
-  it("round-trips: extract after tag returns same content", () => {
-    const original = "Some plan content here.\n\n## Section Two\n\nMore content.";
-    const tagged = tagContent(original, "ai:Louis");
-    const { content } = extractMarks(tagged);
-    expect(content).toBe(original);
-  });
-});

package/src/lib/authorship.ts

@@ -1,280 +0,0 @@
-/**
- * Character-range authorship tracking for plan files.
- *
- * Follows the @proof/core marks model: each mark tracks authorship at the
- * character range level with quote-based re-anchoring when positions shift.
- *
- * @module authorship
- */
-
-// ============================================================================
-// Types (following @proof/core marks model)
-// ============================================================================
-
-export type MarkKind =
-  | "authored"
-  | "approved"
-  | "flagged"
-  | "comment"
-  | "insert"
-  | "delete"
-  | "replace";
-
-export interface MarkRange {
-  from: number;
-  to: number;
-}
-
-export interface Mark {
-  id: string;
-  kind: MarkKind;
-  by: string; // "ai:François" or "human:thijs"
-  at: string; // ISO timestamp
-  range: MarkRange; // character positions in the clean content
-  quote: string; // text content for re-anchoring
-  orphaned?: boolean;
-}
-
-export interface MarksDocument {
-  version: number;
-  marks: Record<string, Mark>;
-}
-
-export interface AuthorshipStats {
-  aiPercent: number;
-  humanPercent: number;
-  totalChars: number;
-}
-
-// ============================================================================
-// Comment block format
-// ============================================================================
-
-const MARKS_START = "<!-- TMUX-IDE:MARKS";
-const MARKS_END = "-->";
-
-// ============================================================================
-// ID generation
-// ============================================================================
-
-let markIdCounter = 0;
-
-export function generateMarkId(): string {
-  return `m${Date.now()}_${++markIdCounter}`;
-}
-
-// ============================================================================
-// Quote normalization (matches @proof/core)
-// ============================================================================
-
-export function normalizeQuote(text: string): string {
-  return text.replace(/\s+/g, " ").trim();
-}
-
-// ============================================================================
-// Extract / Embed
-// ============================================================================
-
-/**
- * Extract marks from a markdown file.
- * Returns clean content (without the comment block) and parsed marks.
- */
-export function extractMarks(markdown: string): {
-  content: string;
-  marks: MarksDocument | null;
-} {
-  const startIdx = markdown.lastIndexOf(MARKS_START);
-  if (startIdx === -1) {
-    return { content: markdown, marks: null };
-  }
-
-  const endIdx = markdown.indexOf(MARKS_END, startIdx + MARKS_START.length);
-  if (endIdx === -1) {
-    return { content: markdown, marks: null };
-  }
-
-  const jsonStr = markdown.slice(startIdx + MARKS_START.length, endIdx).trim();
-  const content = (
-    markdown.slice(0, startIdx) + markdown.slice(endIdx + MARKS_END.length)
-  ).trimEnd();
-
-  try {
-    const data = JSON.parse(jsonStr) as MarksDocument;
-    return { content, marks: data };
-  } catch {
-    return { content, marks: null };
-  }
-}
-
-/**
- * Embed marks into a markdown file.
- * Strips any existing marks comment and appends a new one at the end.
- */
-export function embedMarks(markdown: string, doc: MarksDocument): string {
-  const { content } = extractMarks(markdown);
-  const json = JSON.stringify(doc, null, 2);
-  return `${content}\n\n${MARKS_START}\n${json}\n${MARKS_END}\n`;
-}
-
-// ============================================================================
-// Mark creation helpers
-// ============================================================================
-
-export function createAuthored(by: string, range: MarkRange, quote: string): Mark {
-  return {
-    id: generateMarkId(),
-    kind: "authored",
-    by,
-    at: new Date().toISOString(),
-    range,
-    quote: normalizeQuote(quote),
-  };
-}
-
-// ============================================================================
-// Stats calculation
-// ============================================================================
-
-/**
- * Calculate AI vs human authorship percentages from marks.
- * Only counts 'authored' marks. Uses character range lengths.
- */
-export function calculateStats(marks: Record<string, Mark>): AuthorshipStats {
-  let aiChars = 0;
-  let humanChars = 0;
-
-  for (const mark of Object.values(marks)) {
-    if (mark.kind !== "authored") continue;
-    if (mark.orphaned) continue;
-    const chars = mark.range.to - mark.range.from;
-    if (mark.by.startsWith("ai:") || mark.by === "ai") {
-      aiChars += chars;
-    } else {
-      humanChars += chars;
-    }
-  }
-
-  const totalChars = aiChars + humanChars;
-  if (totalChars === 0) {
-    return { aiPercent: 0, humanPercent: 0, totalChars: 0 };
-  }
-
-  return {
-    aiPercent: Math.round((aiChars / totalChars) * 100),
-    humanPercent: Math.round((humanChars / totalChars) * 100),
-    totalChars,
-  };
-}
-
-// ============================================================================
-// Re-anchoring: recover positions when content shifts
-// ============================================================================
-
-/**
- * Find the position of a quote in content text.
- * Returns { from, to } or null if not found.
- */
-function findQuotePosition(content: string, quote: string): MarkRange | null {
-  if (!quote) return null;
-  const normalized = normalizeQuote(quote);
-  const normalizedContent = normalizeQuote(content);
-  const idx = normalizedContent.indexOf(normalized);
-  if (idx === -1) return null;
-
-  // Map back to original content positions (approximate — whitespace may differ)
-  // Walk through original content counting normalized chars
-  let origFrom = -1;
-  let normalizedPos = 0;
-  for (let i = 0; i < content.length; i++) {
-    if (/\s/.test(content[i]!) && (i === 0 || /\s/.test(content[i - 1]!))) continue;
-    if (normalizedPos === idx && origFrom === -1) origFrom = i;
-    if (normalizedPos === idx + normalized.length) {
-      return { from: origFrom, to: i };
-    }
-    normalizedPos++;
-  }
-
-  // Fallback: simple indexOf on original
-  const simpleIdx = content.indexOf(quote);
-  if (simpleIdx !== -1) {
-    return { from: simpleIdx, to: simpleIdx + quote.length };
-  }
-
-  return null;
-}
-
-/**
- * Re-anchor marks whose ranges may have shifted due to content edits.
- * Uses quote text to find new positions. Marks orphaned if quote not found.
- */
-export function reanchorMarks(content: string, marks: Record<string, Mark>): Record<string, Mark> {
-  const result: Record<string, Mark> = {};
-
-  for (const [id, mark] of Object.entries(marks)) {
-    // Check if current range still matches quote
-    const currentText = content.slice(mark.range.from, mark.range.to);
-    if (normalizeQuote(currentText) === normalizeQuote(mark.quote)) {
-      result[id] = mark;
-      continue;
-    }
-
-    // Try to re-anchor using quote
-    const newRange = findQuotePosition(content, mark.quote);
-    if (newRange) {
-      result[id] = { ...mark, range: newRange, orphaned: false };
-    } else {
-      result[id] = { ...mark, orphaned: true };
-    }
-  }
-
-  return result;
-}
-
-// ============================================================================
-// Tagging: tag entire content as authored by a given actor
-// ============================================================================
-
-/**
- * Tag the full content as authored by the given actor.
- * Preserves existing marks and only adds a mark for uncovered ranges.
- */
-export function tagContent(markdown: string, by: string): string {
-  const { content, marks: existingDoc } = extractMarks(markdown);
-  const existingMarks = existingDoc?.marks ?? {};
-
-  // Re-anchor existing marks against current content
-  const anchored =
-    Object.keys(existingMarks).length > 0 ? reanchorMarks(content, existingMarks) : {};
-
-  // Find uncovered character ranges
-  const covered = new Set<number>();
-  for (const mark of Object.values(anchored)) {
-    if (mark.kind !== "authored" || mark.orphaned) continue;
-    for (let i = mark.range.from; i < mark.range.to && i < content.length; i++) {
-      covered.add(i);
-    }
-  }
-
-  // Build marks for uncovered ranges (coalesce adjacent)
-  const newMarks: Record<string, Mark> = { ...anchored };
-  let rangeStart = -1;
-
-  for (let i = 0; i <= content.length; i++) {
-    const isCovered = covered.has(i);
-    const atEnd = i === content.length;
-
-    if (!isCovered && !atEnd && rangeStart === -1) {
-      rangeStart = i;
-    } else if ((isCovered || atEnd) && rangeStart !== -1) {
-      const quote = content.slice(rangeStart, i);
-      if (quote.trim().length > 0) {
-        const mark = createAuthored(by, { from: rangeStart, to: i }, quote);
-        newMarks[mark.id] = mark;
-      }
-      rangeStart = -1;
-    }
-  }
-
-  const doc: MarksDocument = { version: 2, marks: newMarks };
-  return embedMarks(content, doc);
-}

package/src/lib/cast/recorder.test.ts

@@ -1,127 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from "bun:test";
-import { existsSync, mkdtempSync, readFileSync, rmSync } from "node:fs";
-import { join } from "node:path";
-import { tmpdir } from "node:os";
-import { AsciicastRecorder } from "./recorder.ts";
-
-describe("AsciicastRecorder", () => {
-  let dir: string;
-
-  beforeEach(() => {
-    dir = mkdtempSync(join(tmpdir(), "cast-test-"));
-  });
-
-  afterEach(() => {
-    rmSync(dir, { recursive: true, force: true });
-  });
-
-  it("creates recording directory", () => {
-    const rec = new AsciicastRecorder({
-      dir,
-      session: "test-sess",
-      paneId: "%0",
-    });
-    // Starting will fail since no tmux is running, but the file should be created
-    try {
-      rec.start();
-      rec.stop();
-    } catch {
-      // expected in test environment
-    }
-
-    // The .tasks/recordings/ directory should have been created
-    // existsSync imported at top
-    expect(existsSync(join(dir, ".tasks", "recordings"))).toBe(true);
-  });
-
-  it("writes asciicast v2 header on start", () => {
-    const rec = new AsciicastRecorder({
-      dir,
-      session: "test-sess",
-      paneId: "%0",
-      intervalMs: 60000, // long interval so timer doesn't fire
-    });
-
-    const filePath = rec.start();
-    rec.stop();
-
-    const content = readFileSync(filePath, "utf-8");
-    const lines = content.trim().split("\n");
-    expect(lines.length).toBeGreaterThanOrEqual(1);
-
-    const header = JSON.parse(lines[0]!);
-    expect(header.version).toBe(2);
-    expect(typeof header.width).toBe("number");
-    expect(typeof header.height).toBe("number");
-    expect(typeof header.timestamp).toBe("number");
-    expect(header.width).toBeGreaterThan(0);
-    expect(header.height).toBeGreaterThan(0);
-  });
-
-  it("getFilePath returns the .cast file path", () => {
-    const rec = new AsciicastRecorder({
-      dir,
-      session: "my-session",
-      paneId: "%5",
-    });
-    const path = rec.start();
-    rec.stop();
-    expect(path).toBe(rec.getFilePath());
-    expect(path).toContain(".cast");
-    expect(path).toContain("my-session");
-    expect(path).toContain("5"); // %5 with % stripped
-  });
-
-  it("file is in .tasks/recordings/", () => {
-    const rec = new AsciicastRecorder({
-      dir,
-      session: "s",
-      paneId: "%0",
-    });
-    const path = rec.start();
-    rec.stop();
-    expect(path).toContain(join(".tasks", "recordings"));
-  });
-
-  it("event lines follow asciicast v2 format", () => {
-    // We can't easily capture from a real tmux pane in tests, but we can
-    // verify the header format is correct and that stop doesn't throw.
-    const rec = new AsciicastRecorder({
-      dir,
-      session: "fmt-test",
-      paneId: "%0",
-      intervalMs: 60000,
-    });
-    rec.start();
-    rec.stop();
-
-    const content = readFileSync(rec.getFilePath(), "utf-8");
-    const lines = content.trim().split("\n").filter(Boolean);
-
-    // First line is header
-    const header = JSON.parse(lines[0]!);
-    expect(header.version).toBe(2);
-
-    // Any subsequent lines should be [number, "o", string] arrays
-    for (const line of lines.slice(1)) {
-      const event = JSON.parse(line);
-      expect(Array.isArray(event)).toBe(true);
-      expect(event.length).toBe(3);
-      expect(typeof event[0]).toBe("number"); // elapsed seconds
-      expect(event[1]).toBe("o"); // output event type
-      expect(typeof event[2]).toBe("string"); // data
-    }
-  });
-
-  it("stop is idempotent", () => {
-    const rec = new AsciicastRecorder({
-      dir,
-      session: "s",
-      paneId: "%0",
-      intervalMs: 60000,
-    });
-    rec.start();
-    rec.stop();
-    rec.stop(); // should not throw
-  });
-});