rtfct 0.1.0

package/tests/unit/kanban.test.ts

@@ -0,0 +1,162 @@
+/**
+ * Unit Tests for the Kanban Parser
+ */
+
+import { describe, test, expect } from "bun:test";
+import {
+  countTasks,
+  extractCurrentTask,
+  parseKanbanFile,
+  formatRelativeTime,
+} from "../../src/kanban";
+
+describe("countTasks", () => {
+  test("counts zero tasks in empty content", () => {
+    expect(countTasks("# Backlog\n\nNo tasks here.")).toBe(0);
+  });
+
+  test("counts single task", () => {
+    const content = `# Backlog
+
+## [TASK-001] First Task
+
+Description here.
+`;
+    expect(countTasks(content)).toBe(1);
+  });
+
+  test("counts multiple tasks", () => {
+    const content = `# Backlog
+
+## [TASK-001] First Task
+
+Description.
+
+## [TASK-002] Second Task
+
+Another description.
+
+## [TASK-003] Third Task
+
+Yet another.
+`;
+    expect(countTasks(content)).toBe(3);
+  });
+
+  test("ignores non-task headers", () => {
+    const content = `# Backlog
+
+## [TASK-001] Real Task
+
+## Not a Task
+
+## [OTHER-002] Also Not a Task
+`;
+    expect(countTasks(content)).toBe(1);
+  });
+});
+
+describe("extractCurrentTask", () => {
+  test("returns null for empty content", () => {
+    expect(extractCurrentTask("# In Progress\n\nNo tasks.")).toBeNull();
+  });
+
+  test("extracts task from content", () => {
+    const content = `# In Progress
+
+## [TASK-004] Implement user auth
+
+Description here.
+`;
+    const task = extractCurrentTask(content);
+    expect(task).not.toBeNull();
+    expect(task!.id).toBe("TASK-004");
+    expect(task!.title).toBe("Implement user auth");
+  });
+
+  test("extracts first task when multiple exist", () => {
+    const content = `# In Progress
+
+## [TASK-001] First
+
+## [TASK-002] Second
+`;
+    const task = extractCurrentTask(content);
+    expect(task!.id).toBe("TASK-001");
+    expect(task!.title).toBe("First");
+  });
+});
+
+describe("parseKanbanFile", () => {
+  test("parses backlog file", () => {
+    const content = `# Backlog
+
+## [TASK-001] First
+
+## [TASK-002] Second
+`;
+    const result = parseKanbanFile(content, "backlog");
+    expect(result.count).toBe(2);
+    expect(result.currentTask).toBeNull();
+  });
+
+  test("parses in-progress file with current task", () => {
+    const content = `# In Progress
+
+## [TASK-003] Current Work
+`;
+    const result = parseKanbanFile(content, "in-progress");
+    expect(result.count).toBe(1);
+    expect(result.currentTask).not.toBeNull();
+    expect(result.currentTask!.id).toBe("TASK-003");
+  });
+
+  test("parses done file", () => {
+    const content = `# Done
+
+## [TASK-001] First Completed
+
+## [TASK-002] Second Completed
+`;
+    const result = parseKanbanFile(content, "done");
+    expect(result.count).toBe(2);
+    expect(result.currentTask).toBeNull();
+  });
+});
+
+describe("formatRelativeTime", () => {
+  test("formats just now", () => {
+    const now = new Date();
+    expect(formatRelativeTime(now)).toBe("just now");
+  });
+
+  test("formats minutes ago", () => {
+    const fiveMinutesAgo = new Date(Date.now() - 5 * 60 * 1000);
+    expect(formatRelativeTime(fiveMinutesAgo)).toBe("5 minutes ago");
+  });
+
+  test("formats single minute", () => {
+    const oneMinuteAgo = new Date(Date.now() - 1 * 60 * 1000);
+    expect(formatRelativeTime(oneMinuteAgo)).toBe("1 minute ago");
+  });
+
+  test("formats hours ago", () => {
+    const threeHoursAgo = new Date(Date.now() - 3 * 60 * 60 * 1000);
+    expect(formatRelativeTime(threeHoursAgo)).toBe("3 hours ago");
+  });
+
+  test("formats single hour", () => {
+    const oneHourAgo = new Date(Date.now() - 1 * 60 * 60 * 1000);
+    expect(formatRelativeTime(oneHourAgo)).toBe("1 hour ago");
+  });
+
+  test("formats days ago", () => {
+    const twoDaysAgo = new Date(Date.now() - 2 * 24 * 60 * 60 * 1000);
+    expect(formatRelativeTime(twoDaysAgo)).toBe("2 days ago");
+  });
+
+  test("formats single day", () => {
+    const oneDayAgo = new Date(Date.now() - 1 * 24 * 60 * 60 * 1000);
+    expect(formatRelativeTime(oneDayAgo)).toBe("1 day ago");
+  });
+});

package/tests/unit/manifest.test.ts

@@ -0,0 +1,155 @@
+/**
+ * Unit Tests for the Manifest Reader
+ */
+
+import { describe, test, expect, beforeEach, afterEach } from "bun:test";
+import { mkdir, writeFile, rm } from "fs/promises";
+import { join } from "path";
+import { collectGeneratedPaths, readManifest } from "../../src/manifest";
+
+describe("readManifest", () => {
+  const testDir = "/tmp/rtfct-manifest-test";
+
+  beforeEach(async () => {
+    await mkdir(testDir, { recursive: true });
+  });
+
+  afterEach(async () => {
+    await rm(testDir, { recursive: true, force: true });
+  });
+
+  test("reads valid manifest", async () => {
+    const manifest = {
+      name: "test",
+      version: "1.0.0",
+      description: "Test preset",
+      generated_paths: ["src/", "lib/"],
+    };
+    await writeFile(join(testDir, "manifest.json"), JSON.stringify(manifest));
+
+    const result = await readManifest(testDir);
+    expect(result).not.toBeNull();
+    expect(result!.name).toBe("test");
+    expect(result!.generated_paths).toEqual(["src/", "lib/"]);
+  });
+
+  test("returns null for missing manifest", async () => {
+    const result = await readManifest(testDir);
+    expect(result).toBeNull();
+  });
+
+  test("returns null for invalid JSON", async () => {
+    await writeFile(join(testDir, "manifest.json"), "not valid json");
+
+    const result = await readManifest(testDir);
+    expect(result).toBeNull();
+  });
+});
+
+describe("collectGeneratedPaths", () => {
+  const testDir = "/tmp/rtfct-collect-test";
+  const presetsDir = join(testDir, ".project", "presets");
+
+  beforeEach(async () => {
+    await mkdir(presetsDir, { recursive: true });
+  });
+
+  afterEach(async () => {
+    await rm(testDir, { recursive: true, force: true });
+  });
+
+  test("returns default paths when no presets exist", async () => {
+    // Empty presets directory
+    const paths = await collectGeneratedPaths(testDir);
+    expect(paths).toEqual(["src/", "tests/"]);
+  });
+
+  test("collects paths from single preset", async () => {
+    const presetDir = join(presetsDir, "zig");
+    await mkdir(presetDir);
+    await writeFile(
+      join(presetDir, "manifest.json"),
+      JSON.stringify({
+        name: "zig",
+        version: "1.0.0",
+        description: "Zig preset",
+        generated_paths: ["src/", "build.zig"],
+      })
+    );
+
+    const paths = await collectGeneratedPaths(testDir);
+    expect(paths).toContain("src/");
+    expect(paths).toContain("build.zig");
+  });
+
+  test("collects paths from multiple presets", async () => {
+    // Create zig preset
+    const zigDir = join(presetsDir, "zig");
+    await mkdir(zigDir);
+    await writeFile(
+      join(zigDir, "manifest.json"),
+      JSON.stringify({
+        name: "zig",
+        version: "1.0.0",
+        description: "Zig",
+        generated_paths: ["src/", "build.zig"],
+      })
+    );
+
+    // Create typescript preset
+    const tsDir = join(presetsDir, "typescript");
+    await mkdir(tsDir);
+    await writeFile(
+      join(tsDir, "manifest.json"),
+      JSON.stringify({
+        name: "typescript",
+        version: "1.0.0",
+        description: "TypeScript",
+        generated_paths: ["src/", "tests/"],
+      })
+    );
+
+    const paths = await collectGeneratedPaths(testDir);
+    expect(paths).toContain("src/");
+    expect(paths).toContain("build.zig");
+    expect(paths).toContain("tests/");
+  });
+
+  test("deduplicates paths from multiple presets", async () => {
+    // Both presets have src/
+    const zigDir = join(presetsDir, "zig");
+    await mkdir(zigDir);
+    await writeFile(
+      join(zigDir, "manifest.json"),
+      JSON.stringify({
+        name: "zig",
+        version: "1.0.0",
+        description: "Zig",
+        generated_paths: ["src/"],
+      })
+    );
+
+    const tsDir = join(presetsDir, "typescript");
+    await mkdir(tsDir);
+    await writeFile(
+      join(tsDir, "manifest.json"),
+      JSON.stringify({
+        name: "typescript",
+        version: "1.0.0",
+        description: "TypeScript",
+        generated_paths: ["src/"],
+      })
+    );
+
+    const paths = await collectGeneratedPaths(testDir);
+    // Should only have src/ once
+    const srcCount = paths.filter((p) => p === "src/").length;
+    expect(srcCount).toBe(1);
+  });
+
+  test("returns default when presets directory does not exist", async () => {
+    await rm(presetsDir, { recursive: true, force: true });
+    const paths = await collectGeneratedPaths(testDir);
+    expect(paths).toEqual(["src/", "tests/"]);
+  });
+});

package/tests/unit/presets.test.ts

@@ -0,0 +1,295 @@
+/**
+ * Unit Tests for the Preset System
+ */
+
+import { describe, test, expect, beforeEach, afterEach } from "bun:test";
+import { mkdir, rm, stat } from "fs/promises";
+import { join } from "path";
+import {
+  resolvePreset,
+  resolvePresetSync,
+  writePreset,
+  isPresetInstalled,
+  BASE_PRESET,
+} from "../../src/presets";
+import { ZIG_PRESET } from "../../src/presets/zig";
+import { TYPESCRIPT_PRESET } from "../../src/presets/typescript";
+import { ELIXIR_PRESET } from "../../src/presets/elixir";
+import { parseGitHubRef } from "../../src/presets/github";
+
+describe("resolvePresetSync", () => {
+  test("resolves base preset", () => {
+    const result = resolvePresetSync("base");
+    expect(result.success).toBe(true);
+    if (result.success) {
+      expect(result.preset.name).toBe("base");
+    }
+  });
+
+  test("resolves zig preset", () => {
+    const result = resolvePresetSync("zig");
+    expect(result.success).toBe(true);
+    if (result.success) {
+      expect(result.preset.name).toBe("zig");
+    }
+  });
+
+  test("resolves typescript preset", () => {
+    const result = resolvePresetSync("typescript");
+    expect(result.success).toBe(true);
+    if (result.success) {
+      expect(result.preset.name).toBe("typescript");
+    }
+  });
+
+  test("resolves elixir preset", () => {
+    const result = resolvePresetSync("elixir");
+    expect(result.success).toBe(true);
+    if (result.success) {
+      expect(result.preset.name).toBe("elixir");
+    }
+  });
+
+  test("is case insensitive", () => {
+    const result = resolvePresetSync("ZIG");
+    expect(result.success).toBe(true);
+  });
+
+  test("returns error for unknown preset", () => {
+    const result = resolvePresetSync("unknown");
+    expect(result.success).toBe(false);
+    if (!result.success) {
+      expect(result.error).toContain("Unknown built-in preset");
+    }
+  });
+});
+
+describe("resolvePreset (async)", () => {
+  test("resolves built-in presets", async () => {
+    const result = await resolvePreset("base");
+    expect(result.success).toBe(true);
+    if (result.success) {
+      expect(result.preset.name).toBe("base");
+    }
+  });
+
+  test("is case insensitive", async () => {
+    const result = await resolvePreset("ZIG");
+    expect(result.success).toBe(true);
+  });
+
+  test("returns error for unknown preset", async () => {
+    const result = await resolvePreset("unknown");
+    expect(result.success).toBe(false);
+    if (!result.success) {
+      expect(result.error).toContain("Unknown preset");
+    }
+  });
+
+  test("returns error for local presets (not yet supported)", async () => {
+    const result = await resolvePreset("./local-preset");
+    expect(result.success).toBe(false);
+    if (!result.success) {
+      expect(result.error).toContain("Local presets not yet supported");
+    }
+  });
+
+  test("returns error for absolute local presets (not yet supported)", async () => {
+    const result = await resolvePreset("/absolute/path");
+    expect(result.success).toBe(false);
+    if (!result.success) {
+      expect(result.error).toContain("Local presets not yet supported");
+    }
+  });
+
+  test("attempts GitHub resolution for owner/repo format", async () => {
+    // This will fail because the repo doesn't exist, but it should attempt GitHub resolution
+    const result = await resolvePreset("nonexistent-owner/nonexistent-repo");
+    expect(result.success).toBe(false);
+    if (!result.success) {
+      // Should be a GitHub-related error, not "Unknown preset"
+      expect(result.error).toContain("nonexistent-owner/nonexistent-repo");
+    }
+  });
+});
+
+describe("parseGitHubRef", () => {
+  test("parses owner/repo format", () => {
+    const ref = parseGitHubRef("mattneel/rtfct-preset");
+    expect(ref).not.toBeNull();
+    expect(ref!.owner).toBe("mattneel");
+    expect(ref!.repo).toBe("rtfct-preset");
+    expect(ref!.ref).toBe("main");
+  });
+
+  test("parses owner/repo@branch format", () => {
+    const ref = parseGitHubRef("mattneel/rtfct-preset@develop");
+    expect(ref).not.toBeNull();
+    expect(ref!.owner).toBe("mattneel");
+    expect(ref!.repo).toBe("rtfct-preset");
+    expect(ref!.ref).toBe("develop");
+  });
+
+  test("parses owner/repo@tag format", () => {
+    const ref = parseGitHubRef("mattneel/rtfct-preset@v1.0.0");
+    expect(ref).not.toBeNull();
+    expect(ref!.owner).toBe("mattneel");
+    expect(ref!.repo).toBe("rtfct-preset");
+    expect(ref!.ref).toBe("v1.0.0");
+  });
+
+  test("returns null for invalid format (no slash)", () => {
+    const ref = parseGitHubRef("invalid");
+    expect(ref).toBeNull();
+  });
+
+  test("returns null for invalid format (empty owner)", () => {
+    const ref = parseGitHubRef("/repo");
+    expect(ref).toBeNull();
+  });
+
+  test("returns null for invalid format (empty repo)", () => {
+    const ref = parseGitHubRef("owner/");
+    expect(ref).toBeNull();
+  });
+
+  test("returns null for invalid format (empty branch)", () => {
+    const ref = parseGitHubRef("owner/repo@");
+    expect(ref).toBeNull();
+  });
+
+  test("returns null for too many slashes", () => {
+    const ref = parseGitHubRef("owner/repo/extra");
+    expect(ref).toBeNull();
+  });
+});
+
+describe("writePreset", () => {
+  const testDir = "/tmp/rtfct-preset-write-test";
+
+  beforeEach(async () => {
+    await mkdir(join(testDir, ".project", "presets"), { recursive: true });
+  });
+
+  afterEach(async () => {
+    await rm(testDir, { recursive: true, force: true });
+  });
+
+  test("writes preset files to project", async () => {
+    await writePreset(testDir, ZIG_PRESET);
+
+    const presetDir = join(testDir, ".project", "presets", "zig");
+    const stats = await stat(presetDir);
+    expect(stats.isDirectory()).toBe(true);
+
+    // Check manifest exists
+    const manifestStats = await stat(join(presetDir, "manifest.json"));
+    expect(manifestStats.isFile()).toBe(true);
+  });
+
+  test("writes all preset files", async () => {
+    await writePreset(testDir, ZIG_PRESET);
+
+    const presetDir = join(testDir, ".project", "presets", "zig");
+
+    // Check files exist
+    for (const file of ZIG_PRESET.files) {
+      const filePath = join(presetDir, file.path);
+      const stats = await stat(filePath);
+      expect(stats.isFile()).toBe(true);
+    }
+  });
+});
+
+describe("isPresetInstalled", () => {
+  const testDir = "/tmp/rtfct-preset-installed-test";
+
+  beforeEach(async () => {
+    await mkdir(join(testDir, ".project", "presets"), { recursive: true });
+  });
+
+  afterEach(async () => {
+    await rm(testDir, { recursive: true, force: true });
+  });
+
+  test("returns false when preset not installed", async () => {
+    const result = await isPresetInstalled(testDir, "zig");
+    expect(result).toBe(false);
+  });
+
+  test("returns true when preset is installed", async () => {
+    await writePreset(testDir, ZIG_PRESET);
+    const result = await isPresetInstalled(testDir, "zig");
+    expect(result).toBe(true);
+  });
+});
+
+describe("preset content", () => {
+  test("base preset has all Sacred Text files", () => {
+    expect(BASE_PRESET.files.length).toBeGreaterThan(0);
+    const paths = BASE_PRESET.files.map((f) => f.path);
+    expect(paths).toContain("protocol.md");
+    expect(paths).toContain("theology.md");
+    expect(paths).toContain("kickstart.md");
+    expect(paths).toContain("guardrails.md");
+    expect(paths).toContain("kanban/backlog.md");
+    expect(paths).toContain("kanban/in-progress.md");
+    expect(paths).toContain("kanban/done.md");
+  });
+
+  test("base preset has correct manifest", () => {
+    expect(BASE_PRESET.manifest.name).toBe("base");
+    expect(BASE_PRESET.manifest.version).toBe("0.1.0");
+    expect(BASE_PRESET.manifest.generated_paths).toContain("src/");
+    expect(BASE_PRESET.manifest.generated_paths).toContain("tests/");
+  });
+
+  test("zig preset has required files", () => {
+    expect(ZIG_PRESET.files.length).toBeGreaterThan(0);
+    const paths = ZIG_PRESET.files.map((f) => f.path);
+    expect(paths).toContain("testing/strategy.md");
+    expect(paths).toContain("guardrails.md");
+    expect(paths).toContain("design/patterns.md");
+  });
+
+  test("zig preset has build.zig in generated_paths", () => {
+    expect(ZIG_PRESET.manifest.generated_paths).toContain("build.zig");
+    expect(ZIG_PRESET.manifest.generated_paths).toContain("build.zig.zon");
+  });
+
+  test("zig preset depends on base", () => {
+    expect(ZIG_PRESET.manifest.depends).toContain("base");
+  });
+
+  test("typescript preset has required files", () => {
+    expect(TYPESCRIPT_PRESET.files.length).toBeGreaterThan(0);
+    const paths = TYPESCRIPT_PRESET.files.map((f) => f.path);
+    expect(paths).toContain("testing/strategy.md");
+    expect(paths).toContain("guardrails.md");
+    expect(paths).toContain("design/patterns.md");
+  });
+
+  test("typescript preset has dist in generated_paths", () => {
+    expect(TYPESCRIPT_PRESET.manifest.generated_paths).toContain("dist/");
+  });
+
+  test("typescript preset depends on base", () => {
+    expect(TYPESCRIPT_PRESET.manifest.depends).toContain("base");
+  });
+
+  test("elixir preset has required files", () => {
+    expect(ELIXIR_PRESET.files.length).toBeGreaterThan(0);
+    const paths = ELIXIR_PRESET.files.map((f) => f.path);
+    expect(paths).toContain("testing/strategy.md");
+    expect(paths).toContain("guardrails.md");
+  });
+
+  test("all presets have generated_paths", () => {
+    expect(BASE_PRESET.manifest.generated_paths.length).toBeGreaterThan(0);
+    expect(ZIG_PRESET.manifest.generated_paths.length).toBeGreaterThan(0);
+    expect(TYPESCRIPT_PRESET.manifest.generated_paths.length).toBeGreaterThan(
+      0
+    );
+    expect(ELIXIR_PRESET.manifest.generated_paths.length).toBeGreaterThan(0);
+  });
+});

package/tsconfig.json

@@ -0,0 +1,19 @@
+{
+  "compilerOptions": {
+    "target": "ESNext",
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "strict": true,
+    "skipLibCheck": true,
+    "noEmit": true,
+    "esModuleInterop": true,
+    "allowSyntheticDefaultImports": true,
+    "resolveJsonModule": true,
+    "isolatedModules": true,
+    "verbatimModuleSyntax": true,
+    "lib": ["ESNext"],
+    "types": ["bun-types"]
+  },
+  "include": ["src/**/*", "tests/**/*"],
+  "exclude": ["node_modules", "dist"]
+}