tmux-ide 1.2.1 → 2.0.0

package/src/lib/skill-registry.test.ts

@@ -0,0 +1,134 @@
+import { describe, it, beforeEach, afterEach, expect } from "bun:test";
+import { mkdtempSync, rmSync, mkdirSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { loadSkills, loadSkill } from "./skill-registry.ts";
+
+let tmpDir: string;
+
+beforeEach(() => {
+  tmpDir = mkdtempSync(join(tmpdir(), "tmux-ide-skill-test-"));
+});
+
+afterEach(() => {
+  rmSync(tmpDir, { recursive: true, force: true });
+});
+
+describe("loadSkills", () => {
+  it("returns empty array when skills dir does not exist", () => {
+    expect(loadSkills(tmpDir)).toEqual([]);
+  });
+
+  it("loads skill from markdown file with YAML frontmatter", () => {
+    const skillsDir = join(tmpDir, ".tmux-ide", "skills");
+    mkdirSync(skillsDir, { recursive: true });
+    writeFileSync(
+      join(skillsDir, "frontend.md"),
+      `---
+name: frontend
+specialties: [react, css, typescript]
+role: teammate
+description: Frontend component specialist
+---
+You are a frontend developer. Focus on React components and CSS.
+`,
+    );
+
+    const skills = loadSkills(tmpDir);
+    expect(skills.length).toBe(1);
+    expect(skills[0]!.name).toBe("frontend");
+    expect(skills[0]!.specialties).toEqual(["react", "css", "typescript"]);
+    expect(skills[0]!.role).toBe("teammate");
+    expect(skills[0]!.description).toBe("Frontend component specialist");
+    expect(skills[0]!.body).toBe(
+      "You are a frontend developer. Focus on React components and CSS.",
+    );
+  });
+
+  it("loads multiple skills", () => {
+    const skillsDir = join(tmpDir, ".tmux-ide", "skills");
+    mkdirSync(skillsDir, { recursive: true });
+    writeFileSync(
+      join(skillsDir, "backend.md"),
+      `---
+name: backend
+specialties: api, database
+role: teammate
+description: Backend API specialist
+---
+Backend instructions.
+`,
+    );
+    writeFileSync(
+      join(skillsDir, "qa.md"),
+      `---
+name: qa
+role: validator
+description: QA validator
+---
+QA instructions.
+`,
+    );
+
+    const skills = loadSkills(tmpDir);
+    expect(skills.length).toBe(2);
+  });
+
+  it("parses comma-separated specialties string", () => {
+    const skillsDir = join(tmpDir, ".tmux-ide", "skills");
+    mkdirSync(skillsDir, { recursive: true });
+    writeFileSync(
+      join(skillsDir, "test.md"),
+      `---
+name: test
+specialties: api, database, auth
+---
+Body.
+`,
+    );
+
+    const skills = loadSkills(tmpDir);
+    expect(skills[0]!.specialties).toEqual(["api", "database", "auth"]);
+  });
+
+  it("skips files without valid frontmatter", () => {
+    const skillsDir = join(tmpDir, ".tmux-ide", "skills");
+    mkdirSync(skillsDir, { recursive: true });
+    writeFileSync(join(skillsDir, "bad.md"), "No frontmatter here");
+
+    expect(loadSkills(tmpDir)).toEqual([]);
+  });
+
+  it("skips non-md files", () => {
+    const skillsDir = join(tmpDir, ".tmux-ide", "skills");
+    mkdirSync(skillsDir, { recursive: true });
+    writeFileSync(join(skillsDir, "readme.txt"), "not a skill");
+
+    expect(loadSkills(tmpDir)).toEqual([]);
+  });
+});
+
+describe("loadSkill", () => {
+  it("returns skill by name", () => {
+    const skillsDir = join(tmpDir, ".tmux-ide", "skills");
+    mkdirSync(skillsDir, { recursive: true });
+    writeFileSync(
+      join(skillsDir, "test.md"),
+      `---
+name: test-skill
+role: teammate
+description: A test skill
+---
+Instructions.
+`,
+    );
+
+    const skill = loadSkill(tmpDir, "test-skill");
+    expect(skill).not.toBeNull();
+    expect(skill!.name).toBe("test-skill");
+  });
+
+  it("returns null for unknown skill", () => {
+    expect(loadSkill(tmpDir, "nonexistent")).toBeNull();
+  });
+});

package/src/lib/skill-registry.ts

@@ -0,0 +1,86 @@
+import { join } from "node:path";
+import { homedir } from "node:os";
+import { existsSync, readdirSync, readFileSync } from "node:fs";
+import yaml from "js-yaml";
+
+export interface Skill {
+  name: string;
+  specialties: string[];
+  role: string;
+  description: string;
+  body: string;
+}
+
+const SKILLS_DIR = ".tmux-ide/skills";
+
+/**
+ * Parse a skill markdown file with YAML frontmatter.
+ * Format: --- \n YAML \n --- \n body
+ */
+function parseSkillFile(content: string): Skill | null {
+  const match = content.match(/^---\n([\s\S]*?)\n---\n?([\s\S]*)$/);
+  if (!match) return null;
+
+  try {
+    const meta = yaml.load(match[1]!) as Record<string, unknown>;
+    const name = (meta.name as string) ?? "";
+    if (!name) return null;
+
+    const rawSpecialties = meta.specialties;
+    const specialties = Array.isArray(rawSpecialties)
+      ? (rawSpecialties as string[]).map((s) => String(s).toLowerCase())
+      : typeof rawSpecialties === "string"
+        ? rawSpecialties.split(",").map((s) => s.trim().toLowerCase())
+        : [];
+
+    return {
+      name,
+      specialties,
+      role: (meta.role as string) ?? "teammate",
+      description: (meta.description as string) ?? "",
+      body: (match[2] ?? "").trim(),
+    };
+  } catch {
+    return null;
+  }
+}
+
+function loadSkillsFromDir(skillsDir: string): Skill[] {
+  if (!existsSync(skillsDir)) return [];
+  const files = readdirSync(skillsDir).filter((f) => f.endsWith(".md"));
+  const skills: Skill[] = [];
+  for (const file of files) {
+    const content = readFileSync(join(skillsDir, file), "utf-8");
+    const skill = parseSkillFile(content);
+    if (skill) skills.push(skill);
+  }
+  return skills;
+}
+
+/**
+ * Load all skill definitions from .tmux-ide/skills/*.md (project)
+ * and ~/.tmux-ide/skills/*.md (personal). Project skills take precedence.
+ */
+export function loadSkills(dir: string): Skill[] {
+  const projectSkills = loadSkillsFromDir(join(dir, SKILLS_DIR));
+  const personalDir = join(homedir(), SKILLS_DIR);
+  const personalSkills = loadSkillsFromDir(personalDir);
+
+  // Project skills take precedence over personal skills by name
+  const nameSet = new Set(projectSkills.map((s) => s.name));
+  for (const ps of personalSkills) {
+    if (!nameSet.has(ps.name)) {
+      projectSkills.push(ps);
+    }
+  }
+
+  return projectSkills;
+}
+
+/**
+ * Load a single skill by name.
+ */
+export function loadSkill(dir: string, name: string): Skill | null {
+  const skills = loadSkills(dir);
+  return skills.find((s) => s.name === name) ?? null;
+}

package/src/lib/slugify.test.ts

@@ -0,0 +1,35 @@
+import { describe, it, expect } from "bun:test";
+import { slugify } from "./slugify.ts";
+
+describe("slugify", () => {
+  it("lowercases and replaces non-alphanumeric with hyphens", () => {
+    expect(slugify("Hello World")).toBe("hello-world");
+  });
+
+  it("collapses multiple non-alphanumeric chars into one hyphen", () => {
+    expect(slugify("foo---bar   baz")).toBe("foo-bar-baz");
+  });
+
+  it("trims leading and trailing hyphens", () => {
+    expect(slugify("--hello--")).toBe("hello");
+  });
+
+  it("defaults to maxLen 40", () => {
+    const long = "a".repeat(60);
+    expect(slugify(long)).toHaveLength(40);
+  });
+
+  it("respects custom maxLen", () => {
+    const long = "a".repeat(60);
+    expect(slugify(long, 50)).toHaveLength(50);
+    expect(slugify(long, 30)).toHaveLength(30);
+  });
+
+  it("handles empty string", () => {
+    expect(slugify("")).toBe("");
+  });
+
+  it("handles special characters", () => {
+    expect(slugify("feat: add @auth/login!")).toBe("feat-add-auth-login");
+  });
+});

package/src/lib/slugify.ts

@@ -0,0 +1,10 @@
+/**
+ * Convert text to a URL/filename-safe slug.
+ */
+export function slugify(text: string, maxLen = 40): string {
+  return text
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, "-")
+    .replace(/^-|-$/g, "")
+    .slice(0, maxLen);
+}

package/src/lib/task-store.ts

@@ -0,0 +1,352 @@
+import { resolve, join } from "node:path";
+import { slugify } from "./slugify.ts";
+import {
+  readdirSync,
+  readFileSync,
+  writeFileSync,
+  mkdirSync,
+  existsSync,
+  unlinkSync,
+  renameSync,
+} from "node:fs";
+import type { ProofSchema } from "../types.ts";
+
+const TASKS_DIR = ".tasks";
+const SCHEMA_VERSION = 1;
+
+/**
+ * Write JSON data to a file atomically.
+ * Writes to a temp file first, then renames (atomic on POSIX).
+ * This prevents data loss if the process crashes mid-write.
+ */
+function atomicWriteJSON(filePath: string, data: unknown): void {
+  const tmpPath = filePath + ".tmp";
+  writeFileSync(tmpPath, JSON.stringify(data, null, 2) + "\n");
+  renameSync(tmpPath, filePath);
+}
+
+export interface Milestone {
+  id: string;
+  title: string;
+  description: string;
+  status: "locked" | "active" | "done" | "validating";
+  order: number;
+  created: string;
+  updated: string;
+}
+
+export interface Mission {
+  title: string;
+  description: string;
+  status: "planning" | "active" | "validating" | "complete";
+  branch: string | null;
+  milestones: Milestone[];
+  created: string;
+  updated: string;
+}
+
+export interface Goal {
+  id: string;
+  title: string;
+  description: string;
+  status: "todo" | "in-progress" | "done";
+  acceptance: string;
+  priority: number;
+  created: string;
+  updated: string;
+  assignee: string | null;
+  specialty: string | null;
+  milestone: string | null;
+}
+
+export interface Task {
+  id: string;
+  title: string;
+  description: string;
+  goal: string | null;
+  status: "todo" | "in-progress" | "review" | "done";
+  assignee: string | null;
+  priority: number;
+  created: string;
+  updated: string;
+  tags: string[];
+  proof: ProofSchema | null;
+  retryCount: number;
+  maxRetries: number;
+  lastError: string | null;
+  nextRetryAt: string | null;
+  depends_on: string[];
+  milestone: string | null;
+  specialty: string | null;
+  fulfills: string[];
+  discoveredIssues: string[];
+  salientSummary: string | null;
+}
+
+export function normalizeMission(raw: Record<string, unknown>): Mission {
+  const epoch = "1970-01-01T00:00:00.000Z";
+  return {
+    title: (raw.title as string) ?? "",
+    description: (raw.description as string) ?? "",
+    status: (raw.status as Mission["status"]) ?? "active",
+    branch: (raw.branch as string | null) ?? null,
+    milestones: Array.isArray(raw.milestones) ? (raw.milestones as Milestone[]) : [],
+    created: (raw.created as string) ?? epoch,
+    updated: (raw.updated as string) ?? epoch,
+  };
+}
+
+export function normalizeGoal(raw: Record<string, unknown>): Goal {
+  const epoch = "1970-01-01T00:00:00.000Z";
+  const rest = { ...raw };
+  delete rest._version;
+  return {
+    ...(rest as Omit<Goal, "assignee" | "specialty" | "created" | "updated">),
+    created: (raw.created as string) ?? epoch,
+    updated: (raw.updated as string) ?? epoch,
+    assignee: (raw.assignee as string) ?? null,
+    specialty: (raw.specialty as string) ?? null,
+    milestone: (raw.milestone as string | null) ?? null,
+  } as Goal;
+}
+
+export function normalizeTask(raw: Record<string, unknown>): Task {
+  const defaults = {
+    retryCount: 0,
+    maxRetries: 5,
+    lastError: null,
+    nextRetryAt: null,
+    depends_on: [] as string[],
+  };
+
+  // Migrate proof.note → proof.notes
+  const proof = raw.proof as Record<string, unknown> | null | undefined;
+  if (proof && "note" in proof && !("notes" in proof)) {
+    proof.notes = proof.note;
+    delete proof.note;
+  }
+
+  const rest = { ...raw };
+  delete rest._version;
+  return {
+    ...defaults,
+    ...(rest as Omit<
+      Task,
+      "retryCount" | "maxRetries" | "lastError" | "nextRetryAt" | "depends_on"
+    >),
+    retryCount: (raw.retryCount as number) ?? defaults.retryCount,
+    maxRetries: (raw.maxRetries as number) ?? defaults.maxRetries,
+    lastError: (raw.lastError as string | null) ?? defaults.lastError,
+    nextRetryAt: (raw.nextRetryAt as string | null) ?? defaults.nextRetryAt,
+    depends_on: Array.isArray(raw.depends_on) ? (raw.depends_on as string[]) : defaults.depends_on,
+    milestone: (raw.milestone as string | null) ?? null,
+    specialty: (raw.specialty as string | null) ?? null,
+    fulfills: Array.isArray(raw.fulfills) ? (raw.fulfills as string[]) : [],
+    discoveredIssues: Array.isArray(raw.discoveredIssues) ? (raw.discoveredIssues as string[]) : [],
+    salientSummary: (raw.salientSummary as string | null) ?? null,
+  } as Task;
+}
+
+export function getTasksRoot(dir: string): string {
+  return resolve(dir, TASKS_DIR);
+}
+
+export function ensureTasksDir(dir: string): void {
+  const root = getTasksRoot(dir);
+  if (!existsSync(root)) mkdirSync(root, { recursive: true });
+  const goalsDir = join(root, "goals");
+  if (!existsSync(goalsDir)) mkdirSync(goalsDir);
+  const tasksDir = join(root, "tasks");
+  if (!existsSync(tasksDir)) mkdirSync(tasksDir);
+}
+
+// --- Mission ---
+
+export function loadMission(dir: string): Mission | null {
+  const path = join(getTasksRoot(dir), "mission.json");
+  if (!existsSync(path)) return null;
+  try {
+    return normalizeMission(JSON.parse(readFileSync(path, "utf-8")));
+  } catch (err) {
+    console.error("[task-store] Failed to parse mission.json: %s", (err as Error).message);
+    return null;
+  }
+}
+
+export function saveMission(dir: string, mission: Mission): void {
+  ensureTasksDir(dir);
+  atomicWriteJSON(join(getTasksRoot(dir), "mission.json"), {
+    _version: SCHEMA_VERSION,
+    ...mission,
+  });
+}
+
+export function clearMission(dir: string): void {
+  const path = join(getTasksRoot(dir), "mission.json");
+  if (existsSync(path)) unlinkSync(path);
+}
+
+// --- Goals ---
+
+function findFileById(directory: string, id: string): string | null {
+  if (!existsSync(directory)) return null;
+  const files = readdirSync(directory).filter((f) => f.endsWith(".json"));
+  for (const file of files) {
+    if (file.startsWith(id + "-") || file === id + ".json") {
+      return join(directory, file);
+    }
+  }
+  return null;
+}
+
+export function nextGoalId(dir: string): string {
+  const goalsDir = join(getTasksRoot(dir), "goals");
+  if (!existsSync(goalsDir)) return "01";
+  const files = readdirSync(goalsDir).filter((f) => f.endsWith(".json"));
+  if (files.length === 0) return "01";
+  const maxId = Math.max(...files.map((f) => parseInt(f.split("-")[0]!, 10) || 0));
+  return String(maxId + 1).padStart(2, "0");
+}
+
+export function loadGoals(dir: string): Goal[] {
+  const goalsDir = join(getTasksRoot(dir), "goals");
+  if (!existsSync(goalsDir)) return [];
+  return readdirSync(goalsDir)
+    .filter((f) => f.endsWith(".json"))
+    .sort()
+    .map((f) => {
+      try {
+        return normalizeGoal(JSON.parse(readFileSync(join(goalsDir, f), "utf-8")));
+      } catch (err) {
+        console.error("[task-store] Failed to parse %s: %s", f, (err as Error).message);
+        return null;
+      }
+    })
+    .filter((g): g is Goal => g !== null);
+}
+
+export function loadGoal(dir: string, id: string): Goal | null {
+  const file = findFileById(join(getTasksRoot(dir), "goals"), id);
+  if (!file) return null;
+  try {
+    return normalizeGoal(JSON.parse(readFileSync(file, "utf-8")));
+  } catch (err) {
+    console.error("[task-store] Failed to parse goal %s: %s", id, (err as Error).message);
+    return null;
+  }
+}
+
+export function saveGoal(dir: string, goal: Goal): void {
+  ensureTasksDir(dir);
+  const goalsDir = join(getTasksRoot(dir), "goals");
+  const existing = findFileById(goalsDir, goal.id);
+  const filename = `${goal.id}-${slugify(goal.title, 50)}.json`;
+  const newPath = join(goalsDir, filename);
+  // Write new file atomically first, then remove old file if slug changed
+  atomicWriteJSON(newPath, { _version: SCHEMA_VERSION, ...goal });
+  if (existing && existing !== newPath) unlinkSync(existing);
+}
+
+export function deleteGoal(dir: string, id: string): boolean {
+  const file = findFileById(join(getTasksRoot(dir), "goals"), id);
+  if (!file) return false;
+  unlinkSync(file);
+  return true;
+}
+
+// --- Tasks ---
+
+export function nextTaskId(dir: string): string {
+  const tasksDir = join(getTasksRoot(dir), "tasks");
+  if (!existsSync(tasksDir)) return "001";
+  const files = readdirSync(tasksDir).filter((f) => f.endsWith(".json"));
+  if (files.length === 0) return "001";
+  const maxId = Math.max(...files.map((f) => parseInt(f.split("-")[0]!, 10) || 0));
+  return String(maxId + 1).padStart(3, "0");
+}
+
+export function loadTasks(dir: string): Task[] {
+  const tasksDir = join(getTasksRoot(dir), "tasks");
+  if (!existsSync(tasksDir)) return [];
+  return readdirSync(tasksDir)
+    .filter((f) => f.endsWith(".json"))
+    .sort()
+    .map((f) => {
+      try {
+        return normalizeTask(JSON.parse(readFileSync(join(tasksDir, f), "utf-8")));
+      } catch (err) {
+        console.error("[task-store] Failed to parse %s: %s", f, (err as Error).message);
+        return null;
+      }
+    })
+    .filter((t): t is Task => t !== null);
+}
+
+export function loadTask(dir: string, id: string): Task | null {
+  const file = findFileById(join(getTasksRoot(dir), "tasks"), id);
+  if (!file) return null;
+  try {
+    return normalizeTask(JSON.parse(readFileSync(file, "utf-8")));
+  } catch (err) {
+    console.error("[task-store] Failed to parse task %s: %s", id, (err as Error).message);
+    return null;
+  }
+}
+
+export function saveTask(dir: string, task: Task): void {
+  ensureTasksDir(dir);
+  const tasksDir = join(getTasksRoot(dir), "tasks");
+  const existing = findFileById(tasksDir, task.id);
+  const filename = `${task.id}-${slugify(task.title, 50)}.json`;
+  const newPath = join(tasksDir, filename);
+  // Write new file atomically first, then remove old file if slug changed
+  atomicWriteJSON(newPath, { _version: SCHEMA_VERSION, ...task });
+  if (existing && existing !== newPath) unlinkSync(existing);
+}
+
+export function deleteTask(dir: string, id: string): boolean {
+  const file = findFileById(join(getTasksRoot(dir), "tasks"), id);
+  if (!file) return false;
+  unlinkSync(file);
+  return true;
+}
+
+export function loadTasksForGoal(dir: string, goalId: string): Task[] {
+  return loadTasks(dir).filter((t) => t.goal === goalId);
+}
+
+/**
+ * Detect dependency cycles. Builds the full dependency graph, applies
+ * the proposed change (taskId → newDeps), then runs DFS from taskId.
+ * Returns the cycle path if found, null otherwise.
+ */
+export function detectCycle(dir: string, taskId: string, newDeps: string[]): string[] | null {
+  const tasks = loadTasks(dir);
+  const depMap = new Map<string, string[]>();
+  for (const t of tasks) {
+    depMap.set(t.id, [...t.depends_on]);
+  }
+  // Apply proposed change
+  depMap.set(taskId, newDeps);
+
+  // DFS from taskId following depends_on edges
+  const visited = new Set<string>();
+  const path: string[] = [];
+
+  function dfs(id: string): string[] | null {
+    if (path.includes(id)) {
+      return [...path.slice(path.indexOf(id)), id];
+    }
+    if (visited.has(id)) return null;
+    visited.add(id);
+    path.push(id);
+    for (const dep of depMap.get(id) ?? []) {
+      const cycle = dfs(dep);
+      if (cycle) return cycle;
+    }
+    path.pop();
+    return null;
+  }
+
+  return dfs(taskId);
+}