rtfct 0.1.0

package/tests/integration/init.test.ts

@@ -0,0 +1,197 @@
+/**
+ * Integration Tests for the Init Command
+ */
+
+import { describe, test, expect, beforeEach, afterEach } from "bun:test";
+import { mkdtemp, rm, stat, readFile, readdir } from "fs/promises";
+import { join } from "path";
+import { runInit, formatInit } from "../../src/commands/init";
+
+describe("init command", () => {
+  let testDir: string;
+
+  beforeEach(async () => {
+    testDir = await mkdtemp("/tmp/rtfct-init-test-");
+  });
+
+  afterEach(async () => {
+    await rm(testDir, { recursive: true, force: true });
+  });
+
+  describe("basic initialization", () => {
+    test("creates .project directory", async () => {
+      const result = await runInit(testDir);
+
+      expect(result.success).toBe(true);
+      const projectDir = join(testDir, ".project");
+      const stats = await stat(projectDir);
+      expect(stats.isDirectory()).toBe(true);
+    });
+
+    test("creates protocol.md", async () => {
+      await runInit(testDir);
+
+      const filePath = join(testDir, ".project", "protocol.md");
+      const stats = await stat(filePath);
+      expect(stats.isFile()).toBe(true);
+    });
+
+    test("creates theology.md", async () => {
+      await runInit(testDir);
+
+      const filePath = join(testDir, ".project", "theology.md");
+      const stats = await stat(filePath);
+      expect(stats.isFile()).toBe(true);
+    });
+
+    test("creates kickstart.md", async () => {
+      await runInit(testDir);
+
+      const filePath = join(testDir, ".project", "kickstart.md");
+      const stats = await stat(filePath);
+      expect(stats.isFile()).toBe(true);
+    });
+
+    test("creates guardrails.md", async () => {
+      await runInit(testDir);
+
+      const filePath = join(testDir, ".project", "guardrails.md");
+      const stats = await stat(filePath);
+      expect(stats.isFile()).toBe(true);
+    });
+
+    test("creates kanban directory with files", async () => {
+      await runInit(testDir);
+
+      const kanbanDir = join(testDir, ".project", "kanban");
+      const stats = await stat(kanbanDir);
+      expect(stats.isDirectory()).toBe(true);
+
+      const files = await readdir(kanbanDir);
+      expect(files).toContain("backlog.md");
+      expect(files).toContain("in-progress.md");
+      expect(files).toContain("done.md");
+    });
+
+    test("creates all subdirectories", async () => {
+      await runInit(testDir);
+
+      const dirs = [
+        "specs",
+        "design",
+        "adrs",
+        "kanban",
+        "testing",
+        "references",
+        "presets",
+      ];
+
+      for (const dir of dirs) {
+        const dirPath = join(testDir, ".project", dir);
+        const stats = await stat(dirPath);
+        expect(stats.isDirectory()).toBe(true);
+      }
+    });
+  });
+
+  describe("existing project handling", () => {
+    test("fails if .project already exists", async () => {
+      // First init
+      await runInit(testDir);
+
+      // Second init should fail
+      const result = await runInit(testDir);
+      expect(result.success).toBe(false);
+      expect(result.message).toContain("already exist");
+    });
+
+    test("succeeds with --force flag", async () => {
+      // First init
+      await runInit(testDir);
+
+      // Second init with force
+      const result = await runInit(testDir, { force: true });
+      expect(result.success).toBe(true);
+    });
+  });
+
+  describe("with presets", () => {
+    test("installs single preset", async () => {
+      const result = await runInit(testDir, { presets: ["zig"] });
+
+      expect(result.success).toBe(true);
+
+      const presetDir = join(testDir, ".project", "presets", "zig");
+      const stats = await stat(presetDir);
+      expect(stats.isDirectory()).toBe(true);
+    });
+
+    test("installs multiple presets", async () => {
+      const result = await runInit(testDir, {
+        presets: ["zig", "typescript"],
+      });
+
+      expect(result.success).toBe(true);
+
+      const zigDir = join(testDir, ".project", "presets", "zig");
+      const tsDir = join(testDir, ".project", "presets", "typescript");
+
+      const zigStats = await stat(zigDir);
+      const tsStats = await stat(tsDir);
+
+      expect(zigStats.isDirectory()).toBe(true);
+      expect(tsStats.isDirectory()).toBe(true);
+    });
+
+    test("reports errors for unknown presets", async () => {
+      const result = await runInit(testDir, { presets: ["unknown"] });
+
+      expect(result.success).toBe(true); // Still succeeds overall
+      expect(result.presetErrors).toBeDefined();
+      expect(result.presetErrors!.length).toBeGreaterThan(0);
+    });
+
+    test("installs valid presets even if some fail", async () => {
+      const result = await runInit(testDir, {
+        presets: ["zig", "unknown"],
+      });
+
+      expect(result.success).toBe(true);
+
+      // Zig should be installed
+      const zigDir = join(testDir, ".project", "presets", "zig");
+      const zigStats = await stat(zigDir);
+      expect(zigStats.isDirectory()).toBe(true);
+
+      // But we should have an error for unknown
+      expect(result.presetErrors!.length).toBe(1);
+    });
+  });
+
+  describe("output formatting", () => {
+    test("formats success message", async () => {
+      const result = await runInit(testDir);
+      const output = formatInit(result);
+
+      expect(output).toContain("✓");
+      expect(output).toContain("consecrated");
+      expect(output).toContain("Omnissiah");
+    });
+
+    test("formats failure message", async () => {
+      await runInit(testDir);
+      const result = await runInit(testDir); // Second init fails
+      const output = formatInit(result);
+
+      expect(output).toContain("✗");
+      expect(output).toContain("already exist");
+    });
+
+    test("formats preset warnings", async () => {
+      const result = await runInit(testDir, { presets: ["unknown"] });
+      const output = formatInit(result);
+
+      expect(output).toContain("warning");
+    });
+  });
+});

package/tests/integration/praise.test.ts

@@ -0,0 +1,36 @@
+/**
+ * Integration Tests for the Praise Command
+ */
+
+import { describe, test, expect } from "bun:test";
+import { runPraise } from "../../src/commands/praise";
+
+describe("praise command", () => {
+  test("outputs the litany", () => {
+    const output = runPraise();
+
+    expect(output).toContain("The flesh is weak, but the protocol is strong.");
+    expect(output).toContain("The code is temporary, but the spec endures.");
+    expect(output).toContain(
+      "The tests do not lie, and the agent does not tire."
+    );
+    expect(output).toContain(
+      "From specification, code. From code, verification. From verification, truth."
+    );
+    expect(output).toContain("The Omnissiah provides.");
+    expect(output).toContain("Praise the Machine Spirit.");
+  });
+
+  test("outputs exactly the expected litany", () => {
+    const output = runPraise();
+
+    const expected = `The flesh is weak, but the protocol is strong.
+The code is temporary, but the spec endures.
+The tests do not lie, and the agent does not tire.
+From specification, code. From code, verification. From verification, truth.
+The Omnissiah provides.
+Praise the Machine Spirit.`;
+
+    expect(output).toBe(expected);
+  });
+});

package/tests/integration/regenerate.test.ts

@@ -0,0 +1,154 @@
+/**
+ * Integration Tests for the Regenerate Command
+ */
+
+import { describe, test, expect, beforeEach, afterEach } from "bun:test";
+import { mkdtemp, rm, stat, mkdir, writeFile } from "fs/promises";
+import { join } from "path";
+import { runInit } from "../../src/commands/init";
+import {
+  runRegenerate,
+  formatRegenerate,
+} from "../../src/commands/regenerate";
+
+describe("regenerate command", () => {
+  let testDir: string;
+
+  beforeEach(async () => {
+    testDir = await mkdtemp("/tmp/rtfct-regen-test-");
+  });
+
+  afterEach(async () => {
+    await rm(testDir, { recursive: true, force: true });
+  });
+
+  describe("without existing project", () => {
+    test("fails if .project does not exist", async () => {
+      const result = await runRegenerate(testDir);
+
+      expect(result.success).toBe(false);
+      expect(result.message).toContain("No .project/ folder found");
+    });
+  });
+
+  describe("confirmation behavior", () => {
+    beforeEach(async () => {
+      await runInit(testDir);
+    });
+
+    test("requires confirmation without --yes", async () => {
+      const result = await runRegenerate(testDir);
+
+      expect(result.success).toBe(true);
+      expect(result.requiresConfirmation).toBe(true);
+      expect(result.pathsToDelete).toBeDefined();
+    });
+
+    test("proceeds with --yes flag", async () => {
+      const result = await runRegenerate(testDir, { yes: true });
+
+      expect(result.success).toBe(true);
+      expect(result.requiresConfirmation).toBeUndefined();
+    });
+  });
+
+  describe("path deletion", () => {
+    beforeEach(async () => {
+      await runInit(testDir);
+    });
+
+    test("deletes default paths when no presets", async () => {
+      // Create src/ and tests/
+      await mkdir(join(testDir, "src"));
+      await writeFile(join(testDir, "src", "index.ts"), "// code");
+      await mkdir(join(testDir, "tests"));
+      await writeFile(join(testDir, "tests", "test.ts"), "// test");
+
+      const result = await runRegenerate(testDir, { yes: true });
+
+      expect(result.success).toBe(true);
+      expect(result.deletedPaths).toContain("src/");
+      expect(result.deletedPaths).toContain("tests/");
+
+      // Verify paths are deleted
+      try {
+        await stat(join(testDir, "src"));
+        expect(true).toBe(false); // Should not reach here
+      } catch {
+        // Expected - directory should not exist
+      }
+    });
+
+    test("deletes paths from preset manifests", async () => {
+      await runInit(testDir, { presets: ["zig"], force: true });
+
+      // Create files that match the zig preset's generated_paths
+      await mkdir(join(testDir, "src"));
+      await writeFile(join(testDir, "src", "main.zig"), "// zig code");
+      await writeFile(join(testDir, "build.zig"), "// build");
+
+      const result = await runRegenerate(testDir, { yes: true });
+
+      expect(result.success).toBe(true);
+      expect(result.deletedPaths).toContain("src/");
+      expect(result.deletedPaths).toContain("build.zig");
+    });
+
+    test("handles non-existent paths gracefully", async () => {
+      // Don't create src/ or tests/
+      const result = await runRegenerate(testDir, { yes: true });
+
+      expect(result.success).toBe(true);
+      // Paths might be empty since nothing existed to delete
+    });
+
+    test("preserves .project directory", async () => {
+      await mkdir(join(testDir, "src"));
+
+      await runRegenerate(testDir, { yes: true });
+
+      // .project should still exist
+      const projectStats = await stat(join(testDir, ".project"));
+      expect(projectStats.isDirectory()).toBe(true);
+
+      // And its files should still exist
+      const protocolStats = await stat(join(testDir, ".project", "protocol.md"));
+      expect(protocolStats.isFile()).toBe(true);
+    });
+  });
+
+  describe("output formatting", () => {
+    beforeEach(async () => {
+      await runInit(testDir);
+    });
+
+    test("formats confirmation request", async () => {
+      const result = await runRegenerate(testDir);
+      const output = formatRegenerate(result);
+
+      expect(output).toContain("Purification");
+      expect(output).toContain("Run with --yes");
+    });
+
+    test("formats success output", async () => {
+      await mkdir(join(testDir, "src"));
+
+      const result = await runRegenerate(testDir, { yes: true });
+      const output = formatRegenerate(result);
+
+      expect(output).toContain("✓");
+      expect(output).toContain("purified");
+      expect(output).toContain("Omnissiah");
+    });
+
+    test("formats failure output", async () => {
+      await rm(testDir, { recursive: true, force: true });
+      testDir = await mkdtemp("/tmp/rtfct-regen-test-");
+
+      const result = await runRegenerate(testDir);
+      const output = formatRegenerate(result);
+
+      expect(output).toContain("✗");
+    });
+  });
+});

package/tests/integration/status.test.ts

@@ -0,0 +1,165 @@
+/**
+ * Integration Tests for the Status Command
+ */
+
+import { describe, test, expect, beforeEach, afterEach } from "bun:test";
+import { mkdtemp, rm, writeFile, mkdir } from "fs/promises";
+import { join } from "path";
+import { runInit } from "../../src/commands/init";
+import { runStatus, formatStatus } from "../../src/commands/status";
+
+describe("status command", () => {
+  let testDir: string;
+
+  beforeEach(async () => {
+    testDir = await mkdtemp("/tmp/rtfct-status-test-");
+  });
+
+  afterEach(async () => {
+    await rm(testDir, { recursive: true, force: true });
+  });
+
+  describe("without existing project", () => {
+    test("fails if .project does not exist", async () => {
+      const result = await runStatus(testDir);
+
+      expect(result.success).toBe(false);
+      expect(result.message).toContain("No .project/ folder found");
+    });
+  });
+
+  describe("with existing project", () => {
+    beforeEach(async () => {
+      await runInit(testDir);
+    });
+
+    test("returns success", async () => {
+      const result = await runStatus(testDir);
+      expect(result.success).toBe(true);
+    });
+
+    test("returns project name", async () => {
+      const result = await runStatus(testDir);
+      expect(result.data).toBeDefined();
+      expect(result.data!.projectName).toBeDefined();
+    });
+
+    test("counts tasks from default kanban files", async () => {
+      const result = await runStatus(testDir);
+
+      // Default template has 1 task in backlog
+      expect(result.data!.backlogCount).toBe(1);
+      expect(result.data!.inProgressCount).toBe(0);
+      expect(result.data!.doneCount).toBe(0);
+    });
+
+    test("returns last activity date", async () => {
+      const result = await runStatus(testDir);
+      expect(result.data!.lastActivity).not.toBeNull();
+    });
+  });
+
+  describe("with custom kanban content", () => {
+    beforeEach(async () => {
+      await runInit(testDir);
+    });
+
+    test("counts multiple backlog tasks", async () => {
+      const backlogContent = `# Backlog
+
+## [TASK-001] First Task
+
+## [TASK-002] Second Task
+
+## [TASK-003] Third Task
+`;
+      await writeFile(
+        join(testDir, ".project", "kanban", "backlog.md"),
+        backlogContent
+      );
+
+      const result = await runStatus(testDir);
+      expect(result.data!.backlogCount).toBe(3);
+    });
+
+    test("extracts current task from in-progress", async () => {
+      const inProgressContent = `# In Progress
+
+## [TASK-004] Implement user auth
+
+Working on it.
+`;
+      await writeFile(
+        join(testDir, ".project", "kanban", "in-progress.md"),
+        inProgressContent
+      );
+
+      const result = await runStatus(testDir);
+      expect(result.data!.inProgressCount).toBe(1);
+      expect(result.data!.currentTask).not.toBeNull();
+      expect(result.data!.currentTask!.id).toBe("TASK-004");
+      expect(result.data!.currentTask!.title).toBe("Implement user auth");
+    });
+
+    test("counts completed tasks", async () => {
+      const doneContent = `# Done
+
+## [TASK-001] First Completed
+
+## [TASK-002] Second Completed
+`;
+      await writeFile(
+        join(testDir, ".project", "kanban", "done.md"),
+        doneContent
+      );
+
+      const result = await runStatus(testDir);
+      expect(result.data!.doneCount).toBe(2);
+    });
+  });
+
+  describe("output formatting", () => {
+    beforeEach(async () => {
+      await runInit(testDir);
+    });
+
+    test("formats success output", async () => {
+      const result = await runStatus(testDir);
+      const output = formatStatus(result);
+
+      expect(output).toContain("rtfct:");
+      expect(output).toContain("Litany of Tasks");
+      expect(output).toContain("Backlog:");
+      expect(output).toContain("In Progress:");
+      expect(output).toContain("Completed:");
+      expect(output).toContain("Omnissiah");
+    });
+
+    test("formats current task", async () => {
+      const inProgressContent = `# In Progress
+
+## [TASK-007] The Holy Task
+`;
+      await writeFile(
+        join(testDir, ".project", "kanban", "in-progress.md"),
+        inProgressContent
+      );
+
+      const result = await runStatus(testDir);
+      const output = formatStatus(result);
+
+      expect(output).toContain("[TASK-007]");
+      expect(output).toContain("The Holy Task");
+    });
+
+    test("formats failure output", async () => {
+      await rm(testDir, { recursive: true, force: true });
+      testDir = await mkdtemp("/tmp/rtfct-status-test-");
+
+      const result = await runStatus(testDir);
+      const output = formatStatus(result);
+
+      expect(output).toContain("✗");
+    });
+  });
+});

package/tests/unit/args.test.ts

@@ -0,0 +1,144 @@
+/**
+ * Unit Tests for the Argument Parser
+ */
+
+import { describe, test, expect } from "bun:test";
+import { parseArgs } from "../../src/args";
+
+describe("parseArgs", () => {
+  describe("commands", () => {
+    test("parses init command", () => {
+      const result = parseArgs(["init"]);
+      expect(result.command).toBe("init");
+      expect(result.error).toBeUndefined();
+    });
+
+    test("parses add command", () => {
+      const result = parseArgs(["add"]);
+      expect(result.command).toBe("add");
+      expect(result.error).toBeUndefined();
+    });
+
+    test("parses status command", () => {
+      const result = parseArgs(["status"]);
+      expect(result.command).toBe("status");
+      expect(result.error).toBeUndefined();
+    });
+
+    test("parses regenerate command", () => {
+      const result = parseArgs(["regenerate"]);
+      expect(result.command).toBe("regenerate");
+      expect(result.error).toBeUndefined();
+    });
+
+    test("parses praise command", () => {
+      const result = parseArgs(["praise"]);
+      expect(result.command).toBe("praise");
+      expect(result.error).toBeUndefined();
+    });
+
+    test("returns error for unknown command", () => {
+      const result = parseArgs(["unknown"]);
+      expect(result.error).toBe("Unknown command: unknown");
+    });
+
+    test("no command returns undefined", () => {
+      const result = parseArgs([]);
+      expect(result.command).toBeUndefined();
+      expect(result.error).toBeUndefined();
+    });
+  });
+
+  describe("flags", () => {
+    test("parses --help flag", () => {
+      const result = parseArgs(["--help"]);
+      expect(result.flags.help).toBe(true);
+    });
+
+    test("parses -h flag", () => {
+      const result = parseArgs(["-h"]);
+      expect(result.flags.help).toBe(true);
+    });
+
+    test("parses --version flag", () => {
+      const result = parseArgs(["--version"]);
+      expect(result.flags.version).toBe(true);
+    });
+
+    test("parses -v flag", () => {
+      const result = parseArgs(["-v"]);
+      expect(result.flags.version).toBe(true);
+    });
+
+    test("parses --force flag", () => {
+      const result = parseArgs(["init", "--force"]);
+      expect(result.flags.force).toBe(true);
+    });
+
+    test("parses -f flag", () => {
+      const result = parseArgs(["init", "-f"]);
+      expect(result.flags.force).toBe(true);
+    });
+
+    test("parses --yes flag", () => {
+      const result = parseArgs(["regenerate", "--yes"]);
+      expect(result.flags.yes).toBe(true);
+    });
+
+    test("parses -y flag", () => {
+      const result = parseArgs(["regenerate", "-y"]);
+      expect(result.flags.yes).toBe(true);
+    });
+
+    test("parses --with flag with single preset", () => {
+      const result = parseArgs(["init", "--with", "zig"]);
+      expect(result.flags.with).toEqual(["zig"]);
+    });
+
+    test("parses --with flag with multiple presets", () => {
+      const result = parseArgs(["init", "--with", "zig,typescript"]);
+      expect(result.flags.with).toEqual(["zig", "typescript"]);
+    });
+
+    test("returns error for unknown flag", () => {
+      const result = parseArgs(["--unknown"]);
+      expect(result.error).toBe("Unknown flag: --unknown");
+    });
+
+    test("returns error for unknown short flag", () => {
+      const result = parseArgs(["-x"]);
+      expect(result.error).toBe("Unknown flag: -x");
+    });
+  });
+
+  describe("arguments", () => {
+    test("collects arguments after command", () => {
+      const result = parseArgs(["add", "zig"]);
+      expect(result.command).toBe("add");
+      expect(result.args).toEqual(["zig"]);
+    });
+
+    test("collects multiple arguments", () => {
+      const result = parseArgs(["add", "zig", "typescript"]);
+      expect(result.args).toEqual(["zig", "typescript"]);
+    });
+  });
+
+  describe("combined", () => {
+    test("parses command with flags and arguments", () => {
+      const result = parseArgs(["init", "--force", "--with", "zig"]);
+      expect(result.command).toBe("init");
+      expect(result.flags.force).toBe(true);
+      expect(result.flags.with).toEqual(["zig"]);
+    });
+
+    test("flags default to false", () => {
+      const result = parseArgs(["init"]);
+      expect(result.flags.help).toBe(false);
+      expect(result.flags.version).toBe(false);
+      expect(result.flags.force).toBe(false);
+      expect(result.flags.yes).toBe(false);
+      expect(result.flags.with).toEqual([]);
+    });
+  });
+});