tuiboard 0.5.0

package/src/scripts/parse-check.ts

@@ -0,0 +1,124 @@
+/**
+ * CLI smoke-test for the markdown parser.
+ *
+ * Usage:
+ *   bun run src/scripts/parse-check.ts                # uses config-discovered boards
+ *   bun run src/scripts/parse-check.ts <file.md>...   # parses specific files
+ *
+ * Prints per-board summary: columns, task counts, metadata coverage,
+ * diagnostics, and a sample of parsed tasks so we can eyeball correctness.
+ */
+
+import { readFileSync } from "node:fs";
+import { loadConfig } from "~/config/loader";
+import { isTask, parseBoard } from "~/parser/markdown";
+import type { Task } from "~/types";
+
+const args = process.argv.slice(2);
+const files: string[] = [];
+
+if (args.length > 0) {
+  files.push(...args);
+} else {
+  const cfg = loadConfig();
+  if (!cfg.loaded) {
+    console.error(
+      `No .tuiboard/config.yaml found from ${cfg.root}. Using fallback scan of cwd.`,
+    );
+  }
+  if (cfg.boards.length === 0) {
+    console.error("No boards configured and none found via fallback scan.");
+    process.exit(1);
+  }
+  files.push(...cfg.boards.map((b) => b.path));
+}
+
+let totalTasks = 0;
+let totalDone = 0;
+let totalWithSched = 0;
+let totalWithTimeBlock = 0;
+let totalLegacyTimeBlock = 0;
+let totalWithPriority = 0;
+let totalDiagnostics = 0;
+
+for (const file of files) {
+  let content: string;
+  try {
+    content = readFileSync(file, "utf-8");
+  } catch (e) {
+    console.error(`✗ Cannot read ${file}: ${(e as Error).message}`);
+    continue;
+  }
+
+  const { board, diagnostics } = parseBoard(content, { filepath: file });
+  const tasks: Task[] = [];
+  for (const col of board.columns) {
+    for (const child of col.children) {
+      if (isTask(child)) tasks.push(child);
+    }
+  }
+  const done = tasks.filter((t) => t.done).length;
+  const withSched = tasks.filter((t) => t.scheduled).length;
+  const withTime = tasks.filter((t) => t.timeBlock).length;
+  const legacyTime = tasks.filter((t) => t.timeBlockSource === "legacy-prefix").length;
+  const withPrio = tasks.filter((t) => t.priority !== "none").length;
+
+  totalTasks += tasks.length;
+  totalDone += done;
+  totalWithSched += withSched;
+  totalWithTimeBlock += withTime;
+  totalLegacyTimeBlock += legacyTime;
+  totalWithPriority += withPrio;
+  totalDiagnostics += diagnostics.length;
+
+  console.log(`\n━━━ ${board.name} ━━━`);
+  console.log(`  file:         ${file}`);
+  console.log(`  frontmatter:  ${board.frontmatter ? "yes" : "no"}`);
+  console.log(`  trailer:      ${board.trailer ? "yes" : "no"}`);
+  console.log(`  columns:      ${board.columns.length} — ${board.columns.map((c) => c.name).join(" │ ")}`);
+  console.log(`  tasks total:  ${tasks.length}  (${done} done, ${tasks.length - done} open)`);
+  console.log(`  scheduled:    ${withSched}`);
+  console.log(`  time blocks:  ${withTime}  (${legacyTime} legacy prefix, ${withTime - legacyTime} ⌚)`);
+  console.log(`  priority:     ${withPrio}`);
+  console.log(`  diagnostics:  ${diagnostics.length}`);
+
+  // Show first 3 diagnostics
+  for (const d of diagnostics.slice(0, 3)) {
+    console.log(`    [L${d.line}] ${d.level}: ${d.message}`);
+  }
+  if (diagnostics.length > 3) console.log(`    … and ${diagnostics.length - 3} more`);
+
+  // Show first 5 parsed open tasks for eyeballing
+  const sample = tasks.filter((t) => !t.done).slice(0, 5);
+  if (sample.length > 0) {
+    console.log("\n  sample tasks:");
+    for (const t of sample) {
+      const tb = t.timeBlock
+        ? ` ⌚${fmtMin(t.timeBlock.startMin)}-${fmtMin(t.timeBlock.endMin)}`
+        : "";
+      const sched = t.scheduled ? ` ⏳${t.scheduled}` : "";
+      const prio = t.priority !== "none" ? ` [${t.priority}]` : "";
+      const assignee = t.assignee ? ` @${t.assignee}` : "";
+      const tags = t.tags.length ? ` ${t.tags.map((x) => "#" + x).join(" ")}` : "";
+      console.log(`    • ${truncate(t.displayTitle, 60)}${prio}${assignee}${sched}${tb}${tags}`);
+    }
+  }
+}
+
+console.log("\n━━━ TOTALS ━━━");
+console.log(`  files:        ${files.length}`);
+console.log(`  tasks:        ${totalTasks}  (${totalDone} done)`);
+console.log(`  scheduled:    ${totalWithSched}`);
+console.log(`  time blocks:  ${totalWithTimeBlock}  (${totalLegacyTimeBlock} legacy, ${totalWithTimeBlock - totalLegacyTimeBlock} ⌚)`);
+console.log(`  priority:     ${totalWithPriority}`);
+console.log(`  diagnostics:  ${totalDiagnostics}`);
+
+function fmtMin(m: number): string {
+  const h = Math.floor(m / 60).toString().padStart(2, "0");
+  const mm = (m % 60).toString().padStart(2, "0");
+  return `${h}:${mm}`;
+}
+
+function truncate(s: string, n: number): string {
+  return s.length <= n ? s : s.slice(0, n - 1) + "…";
+}

package/src/scripts/roundtrip-check.ts

@@ -0,0 +1,79 @@
+/**
+ * Roundtrip integrity check.
+ *
+ * Parses each board, serializes it back, and verifies bit-for-bit equality
+ * with the original (no tasks are dirty since we haven't mutated anything,
+ * so `serializeTask` falls through to `rawLine`). Any diff indicates a bug
+ * in the parser or serializer's handling of structural elements (frontmatter,
+ * headings, section breaks, trailer).
+ *
+ * Usage:
+ *   bun run src/scripts/roundtrip-check.ts [file.md ...]
+ *
+ * Exit code 0 on success, 1 on any mismatch.
+ */
+
+import { readFileSync } from "node:fs";
+import { loadConfig } from "~/config/loader";
+import { parseBoard } from "~/parser/markdown";
+import { serializeBoard } from "~/parser/serialize";
+
+const args = process.argv.slice(2);
+const files = args.length > 0 ? args : loadConfig().boards.map((b) => b.path);
+
+if (files.length === 0) {
+  console.error("No boards to check.");
+  process.exit(1);
+}
+
+let failures = 0;
+
+for (const file of files) {
+  let original: string;
+  try {
+    original = readFileSync(file, "utf-8");
+  } catch (e) {
+    console.error(`✗ ${file}: ${(e as Error).message}`);
+    failures++;
+    continue;
+  }
+
+  const { board } = parseBoard(original, { filepath: file });
+  const serialized = serializeBoard(board);
+
+  if (serialized === original) {
+    console.log(`✓ ${file}  (${original.length} bytes, ${board.columns.length} cols)`);
+    continue;
+  }
+
+  // Find the first difference for diagnostics.
+  const minLen = Math.min(serialized.length, original.length);
+  let diffAt = -1;
+  for (let i = 0; i < minLen; i++) {
+    if (serialized[i] !== original[i]) {
+      diffAt = i;
+      break;
+    }
+  }
+  if (diffAt === -1) diffAt = minLen;
+
+  const ctx = (s: string, at: number) => {
+    const from = Math.max(0, at - 40);
+    const to = Math.min(s.length, at + 40);
+    return JSON.stringify(s.slice(from, to));
+  };
+
+  console.error(`✗ ${file}: roundtrip differs at offset ${diffAt}`);
+  console.error(`  original size:    ${original.length}`);
+  console.error(`  serialized size:  ${serialized.length}`);
+  console.error(`  original    @ ${diffAt}: ${ctx(original, diffAt)}`);
+  console.error(`  serialized  @ ${diffAt}: ${ctx(serialized, diffAt)}`);
+  failures++;
+}
+
+if (failures > 0) {
+  console.error(`\n${failures} file(s) failed roundtrip.`);
+  process.exit(1);
+}
+
+console.log(`\nAll ${files.length} board(s) passed roundtrip.`);

package/src/store/agents.test.ts

@@ -0,0 +1,181 @@
+import { describe, expect, it } from "bun:test";
+import {
+  classifyStatus,
+  cwdFromSlug,
+  cwdShort,
+  formatAge,
+  parseTranscript,
+  type LivePidRecord,
+} from "./agents";
+
+describe("cwdFromSlug", () => {
+  it("decodes a Windows drive-letter slug", () => {
+    expect(cwdFromSlug("C--Users-nazza-Documents-Repos-Blits")).toBe(
+      "C:\\Users\\nazza\\Documents\\Repos\\Blits",
+    );
+  });
+
+  it("decodes a POSIX absolute path slug", () => {
+    expect(cwdFromSlug("-home-foo-projects-myrepo")).toBe(
+      "/home/foo/projects/myrepo",
+    );
+  });
+
+  it("decodes a macOS user directory slug", () => {
+    expect(cwdFromSlug("-Users-foo-code-blits")).toBe("/Users/foo/code/blits");
+  });
+
+  it("falls back to host separator for ambiguous bare slugs", () => {
+    // No leading dash and no drive letter — host OS picks the separator.
+    const sep = process.platform === "win32" ? "\\" : "/";
+    expect(cwdFromSlug("workdir-x")).toBe(`workdir${sep}x`);
+  });
+});
+
+describe("cwdShort", () => {
+  it("returns the last 3 parts prefixed with ellipsis when path is long", () => {
+    expect(cwdShort("C:\\Users\\nazza\\Documents\\Repos\\Blits")).toBe(
+      "…Documents\\Repos\\Blits",
+    );
+  });
+
+  it("returns the full path when 3 or fewer parts", () => {
+    expect(cwdShort("C:\\Users\\nazza")).toBe("C:\\Users\\nazza");
+  });
+});
+
+describe("classifyStatus", () => {
+  const now = 1_700_000_000_000; // fixed instant
+  const minutes = (n: number) => n * 60_000;
+  const days = (n: number) => n * 86_400_000;
+
+  it("returns live-busy when PID record fresh AND status busy", () => {
+    const live: LivePidRecord = { mtimeMs: now - minutes(1), status: "busy" };
+    expect(classifyStatus(now, now, live)).toBe("live-busy");
+  });
+
+  it("returns live-idle when PID record fresh AND status idle/missing", () => {
+    const live: LivePidRecord = { mtimeMs: now - minutes(1) };
+    expect(classifyStatus(now, now, live)).toBe("live-idle");
+  });
+
+  it("returns stale-pid when PID record older than 5min", () => {
+    const live: LivePidRecord = { mtimeMs: now - minutes(10), status: "busy" };
+    expect(classifyStatus(now, now, live)).toBe("stale-pid");
+  });
+
+  it("returns dormant when no PID and jsonl mtime within 7 days", () => {
+    expect(classifyStatus(now, now - days(2), undefined)).toBe("dormant");
+  });
+
+  it("returns archived when jsonl mtime older than 7 days and no PID", () => {
+    expect(classifyStatus(now, now - days(10), undefined)).toBe("archived");
+  });
+});
+
+describe("formatAge", () => {
+  const now = 1_700_000_000_000;
+
+  it("formats seconds", () => {
+    expect(formatAge(now - 30_000, now)).toBe("30s");
+  });
+
+  it("formats minutes", () => {
+    expect(formatAge(now - 5 * 60_000, now)).toBe("5m");
+  });
+
+  it("formats hours", () => {
+    expect(formatAge(now - 3 * 3_600_000, now)).toBe("3h");
+  });
+
+  it("formats days", () => {
+    expect(formatAge(now - 2 * 86_400_000, now)).toBe("2d");
+  });
+
+  it("returns dash for zero", () => {
+    expect(formatAge(0, now)).toBe("—");
+  });
+});
+
+describe("parseTranscript", () => {
+  const SAMPLE_JSONL = [
+    JSON.stringify({ type: "user", message: { role: "user", content: "Ciao" }, gitBranch: "main" }),
+    JSON.stringify({
+      type: "assistant",
+      message: {
+        role: "assistant",
+        content: [
+          { type: "text", text: "Hello" },
+          { type: "tool_use", name: "Read" },
+        ],
+      },
+    }),
+    JSON.stringify({ type: "custom-title", customTitle: "Refactor store" }),
+  ].join("\n");
+
+  it("extracts title, last messages, counts, branch", () => {
+    const result = parseTranscript(SAMPLE_JSONL);
+    expect(result.customTitle).toBe("Refactor store");
+    expect(result.lastUser).toBe("Ciao");
+    expect(result.firstHumanUser).toBe("Ciao");
+    expect(result.lastAssistant).toBe("Hello");
+    expect(result.messageCount).toBe(2);
+    expect(result.toolCount).toBe(1);
+    expect(result.gitBranch).toBe("main");
+  });
+
+  it("tolerates malformed lines", () => {
+    const broken = SAMPLE_JSONL + "\n{this is not json\n";
+    const result = parseTranscript(broken);
+    expect(result.lastUser).toBe("Ciao"); // still got the good lines
+  });
+
+  it("handles empty input", () => {
+    const result = parseTranscript("");
+    expect(result.messageCount).toBe(0);
+    expect(result.customTitle).toBeUndefined();
+  });
+
+  it("skips skill-bootstrap and system-tag user messages when picking firstHumanUser", () => {
+    const lines = [
+      // Synthetic skill loader injected by Claude Code on /morning
+      JSON.stringify({
+        type: "user",
+        message: {
+          role: "user",
+          content: "Base directory for this skill: C:\\Users\\nazza\\.claude\\skills\\morning",
+        },
+      }),
+      // System-injected reminder tag
+      JSON.stringify({
+        type: "user",
+        message: { role: "user", content: "<system-reminder>do the thing</system-reminder>" },
+      }),
+      // Real human prompt
+      JSON.stringify({
+        type: "user",
+        message: { role: "user", content: "Davvero buongiorno, partiamo dal recap di ieri" },
+      }),
+    ].join("\n");
+    const result = parseTranscript(lines);
+    expect(result.firstHumanUser).toBe("Davvero buongiorno, partiamo dal recap di ieri");
+    // lastUser still tracks the literal last message regardless
+    expect(result.lastUser).toBe("Davvero buongiorno, partiamo dal recap di ieri");
+  });
+
+  it("returns undefined firstHumanUser when every user message is synthetic", () => {
+    const lines = [
+      JSON.stringify({
+        type: "user",
+        message: { role: "user", content: "Base directory for this skill: X" },
+      }),
+      JSON.stringify({
+        type: "user",
+        message: { role: "user", content: "<task-notification>noisy</task-notification>" },
+      }),
+    ].join("\n");
+    const result = parseTranscript(lines);
+    expect(result.firstHumanUser).toBeUndefined();
+    expect(result.lastUser).toBe("<task-notification>noisy</task-notification>");
+  });
+});