trekoon 0.1.0

package/tests/integration/sync-workflow.test.ts

@@ -0,0 +1,279 @@
+import { randomUUID } from "node:crypto";
+import { existsSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+import { afterEach, describe, expect, test } from "bun:test";
+
+import { runInit } from "../../src/commands/init";
+import { runSync } from "../../src/commands/sync";
+import { runWipe } from "../../src/commands/wipe";
+import { okResult, toToonEnvelope } from "../../src/io/output";
+import { appendEventWithGitContext } from "../../src/sync/event-writes";
+import { openTrekoonDatabase } from "../../src/storage/database";
+import { resolveStoragePaths } from "../../src/storage/path";
+
+const tempDirs: string[] = [];
+
+function createWorkspace(): string {
+  const workspace: string = mkdtempSync(join(tmpdir(), "trekoon-integration-"));
+  tempDirs.push(workspace);
+  return workspace;
+}
+
+function runGit(cwd: string, args: readonly string[]): string {
+  const command = Bun.spawnSync({
+    cmd: ["git", ...args],
+    cwd,
+    stdout: "pipe",
+    stderr: "pipe",
+  });
+
+  const stdout: string = new TextDecoder().decode(command.stdout).trim();
+  const stderr: string = new TextDecoder().decode(command.stderr).trim();
+
+  if (command.exitCode !== 0) {
+    throw new Error(`git ${args.join(" ")} failed: ${stderr}`);
+  }
+
+  return stdout;
+}
+
+function seedRepository(workspace: string): void {
+  runGit(workspace, ["init", "-b", "main"]);
+  runGit(workspace, ["config", "user.email", "tests@trekoon.local"]);
+  runGit(workspace, ["config", "user.name", "Trekoon Tests"]);
+  writeFileSync(join(workspace, "README.md"), "# integration repo\n");
+  runGit(workspace, ["add", "README.md"]);
+  runGit(workspace, ["commit", "-m", "seed repo"]);
+}
+
+function commitDb(workspace: string, message: string): void {
+  runGit(workspace, ["add", ".trekoon/trekoon.db"]);
+  runGit(workspace, ["commit", "-m", message]);
+}
+
+interface WorkflowIds {
+  readonly epicId: string;
+  readonly taskId: string;
+  readonly subtaskId: string;
+  readonly depId: string;
+}
+
+function seedTrackerRows(workspace: string): WorkflowIds {
+  const epicId: string = randomUUID();
+  const taskId: string = randomUUID();
+  const subtaskId: string = randomUUID();
+  const depId: string = randomUUID();
+  const now: number = Date.now();
+
+  const storage = openTrekoonDatabase(workspace);
+  try {
+    storage.db
+      .query("INSERT INTO epics (id, title, description, status, created_at, updated_at, version) VALUES (?, ?, ?, ?, ?, ?, 1);")
+      .run(epicId, "Sync epic", "integration", "open", now, now);
+
+    storage.db
+      .query(
+        "INSERT INTO tasks (id, epic_id, title, description, status, created_at, updated_at, version) VALUES (?, ?, ?, ?, ?, ?, ?, 1);",
+      )
+      .run(taskId, epicId, "Sync task", "integration", "open", now, now);
+
+    storage.db
+      .query(
+        "INSERT INTO subtasks (id, task_id, title, description, status, created_at, updated_at, version) VALUES (?, ?, ?, ?, ?, ?, ?, 1);",
+      )
+      .run(subtaskId, taskId, "Sync subtask", "integration", "open", now, now);
+
+    storage.db
+      .query(
+        "INSERT INTO dependencies (id, source_id, source_kind, depends_on_id, depends_on_kind, created_at, updated_at, version) VALUES (?, ?, ?, ?, ?, ?, ?, 1);",
+      )
+      .run(depId, taskId, "task", subtaskId, "subtask", now, now);
+
+    appendEventWithGitContext(storage.db, workspace, {
+      entityKind: "epic",
+      entityId: epicId,
+      operation: "upsert",
+      fields: {
+        title: "Sync epic",
+        description: "integration",
+        status: "open",
+      },
+    });
+
+    appendEventWithGitContext(storage.db, workspace, {
+      entityKind: "task",
+      entityId: taskId,
+      operation: "upsert",
+      fields: {
+        epic_id: epicId,
+        title: "Sync task",
+        description: "integration",
+        status: "open",
+      },
+    });
+
+    appendEventWithGitContext(storage.db, workspace, {
+      entityKind: "subtask",
+      entityId: subtaskId,
+      operation: "upsert",
+      fields: {
+        task_id: taskId,
+        title: "Sync subtask",
+        description: "integration",
+        status: "open",
+      },
+    });
+  } finally {
+    storage.close();
+  }
+
+  return {
+    epicId,
+    taskId,
+    subtaskId,
+    depId,
+  };
+}
+
+afterEach((): void => {
+  while (tempDirs.length > 0) {
+    const workspace: string | undefined = tempDirs.pop();
+    if (workspace) {
+      rmSync(workspace, { recursive: true, force: true });
+    }
+  }
+});
+
+describe("integration sync workflow", (): void => {
+  test("init -> entity flow -> sync -> wipe", async (): Promise<void> => {
+    const workspace: string = createWorkspace();
+    seedRepository(workspace);
+
+    const initResult = await runInit({
+      args: [],
+      cwd: workspace,
+      mode: "human",
+    });
+    expect(initResult.ok).toBe(true);
+
+    const ids = seedTrackerRows(workspace);
+    commitDb(workspace, "add main tracker records");
+
+    runGit(workspace, ["checkout", "-b", "feature/integration-sync"]);
+
+    {
+      const storage = openTrekoonDatabase(workspace);
+      try {
+        storage.db
+          .query("UPDATE epics SET title = ?, updated_at = ?, version = version + 1 WHERE id = ?;")
+          .run("Local sync epic", Date.now(), ids.epicId);
+
+        appendEventWithGitContext(storage.db, workspace, {
+          entityKind: "epic",
+          entityId: ids.epicId,
+          operation: "upsert",
+          fields: { title: "Local sync epic" },
+        });
+      } finally {
+        storage.close();
+      }
+    }
+
+    const epicStorage = openTrekoonDatabase(workspace);
+    try {
+      const epic = epicStorage.db.query("SELECT id, title, status FROM epics WHERE id = ?;").get(ids.epicId) as {
+        id: string;
+        title: string;
+        status: string;
+      };
+      const task = epicStorage.db.query("SELECT id, title, status FROM tasks WHERE id = ?;").get(ids.taskId) as {
+        id: string;
+        title: string;
+        status: string;
+      };
+      const subtask = epicStorage.db
+        .query("SELECT id, title, status FROM subtasks WHERE id = ?;")
+        .get(ids.subtaskId) as { id: string; title: string; status: string };
+
+      const toon = toToonEnvelope(
+        okResult({
+          command: "epic show",
+          human: "integration",
+          data: {
+            tree: {
+              id: epic.id,
+              title: epic.title,
+              status: epic.status,
+              tasks: [
+                {
+                  id: task.id,
+                  title: task.title,
+                  status: task.status,
+                  subtasks: [
+                    {
+                      id: subtask.id,
+                      title: subtask.title,
+                      status: subtask.status,
+                    },
+                  ],
+                },
+              ],
+            },
+          },
+        }),
+      );
+
+      expect(toon.ok).toBe(true);
+      expect((toon.data as { tree: { tasks: Array<{ subtasks: Array<{ id: string }> }> } }).tree.tasks[0]?.subtasks[0]?.id).toBe(
+        ids.subtaskId,
+      );
+    } finally {
+      epicStorage.close();
+    }
+
+    const statusResult = await runSync({
+      args: ["status", "--from", "main"],
+      cwd: workspace,
+      mode: "toon",
+    });
+    expect(statusResult.ok).toBe(true);
+
+    const pullResult = await runSync({
+      args: ["pull", "--from", "main"],
+      cwd: workspace,
+      mode: "toon",
+    });
+    expect(pullResult.ok).toBe(true);
+    expect((pullResult.data as { createdConflicts: number }).createdConflicts).toBe(1);
+
+    const conflictStorage = openTrekoonDatabase(workspace);
+    try {
+      const conflict = conflictStorage.db
+        .query("SELECT id FROM sync_conflicts WHERE resolution = 'pending' LIMIT 1;")
+        .get() as { id: string } | null;
+
+      expect(conflict?.id).toBeDefined();
+
+      const resolveResult = await runSync({
+        args: ["resolve", conflict!.id, "--use", "theirs"],
+        cwd: workspace,
+        mode: "toon",
+      });
+      expect(resolveResult.ok).toBe(true);
+    } finally {
+      conflictStorage.close();
+    }
+
+    const wipeResult = await runWipe({
+      args: ["--yes"],
+      cwd: workspace,
+      mode: "human",
+    });
+    expect(wipeResult.ok).toBe(true);
+
+    const storagePaths = resolveStoragePaths(workspace);
+    expect(existsSync(storagePaths.storageDir)).toBe(false);
+  });
+});

package/tests/io/human-table.test.ts

@@ -0,0 +1,81 @@
+import { describe, expect, test } from "bun:test";
+
+import { formatHumanTable } from "../../src/io/human-table";
+
+describe("formatHumanTable", (): void => {
+  test("renders a standard table", (): void => {
+    const output = formatHumanTable(
+      ["ID", "TITLE", "STATUS"],
+      [["a1b2c3d4", "Short title", "todo"]],
+      { maxWidth: 120, wrapColumns: [1] },
+    );
+
+    expect(output).toContain("ID");
+    expect(output).toContain("TITLE");
+    expect(output).toContain("Short title");
+  });
+
+  test("wraps long text into multiline rows", (): void => {
+    const output = formatHumanTable(
+      ["ID", "TITLE", "DESCRIPTION"],
+      [
+        [
+          "0bcc31b2",
+          "Review branch changes",
+          "Review all commits and diffs in feature/image-upload-gitlab, provide feedback, and confirm merge readiness.",
+        ],
+      ],
+      { maxWidth: 72, wrapColumns: [1, 2] },
+    );
+
+    const lines = output.split("\n");
+    expect(lines.length).toBeGreaterThan(4);
+    expect(output).toContain("merge readiness.");
+    expect(output).toContain("Review");
+    expect(output).toContain("branch");
+  });
+
+  test("keeps non-wrap columns single-line on narrow widths", (): void => {
+    const output = formatHumanTable(
+      ["ID", "TITLE", "STATUS"],
+      [["TASK-2026-000001", "This title should wrap on a narrow terminal width", "in_progress"]],
+      { maxWidth: 30, wrapColumns: [1] },
+    );
+
+    const lines = output.split("\n");
+    expect(lines.length).toBeGreaterThan(4);
+    expect(output).toContain("TASK-2026-000001");
+    expect(output).toContain("in_progress");
+
+    const dataLines = lines.slice(2);
+    const wrappedTitleLines = dataLines
+      .map((line) => line.split(" | "))
+      .filter((parts) => parts.length === 3 && parts[0]?.trim() === "" && parts[2]?.trim() === "")
+      .map((parts) => parts[1]?.trim() ?? "")
+      .filter((value) => value.length > 0);
+
+    expect(wrappedTitleLines.length).toBeGreaterThan(0);
+  });
+
+  test("does not wrap non-configured columns", (): void => {
+    const output = formatHumanTable(
+      ["ID", "TYPE", "SUMMARY"],
+      [["a1b2c3d4", "feature_request", "Add export support for markdown notes from the timeline view"]],
+      { maxWidth: 32, wrapColumns: [2] },
+    );
+
+    const rowLines = output.split("\n").slice(2);
+    expect(rowLines[0]).toContain("a1b2c3d4");
+    expect(rowLines[0]).toContain("feature_request");
+    expect(rowLines.some((line) => line.includes("feature_request"))).toBe(true);
+    expect(rowLines.filter((line) => line.includes("feature_request")).length).toBe(1);
+
+    const wrappedSummaryLines = rowLines
+      .map((line) => line.split(" | "))
+      .filter((parts) => parts.length === 3 && parts[0]?.trim() === "" && parts[1]?.trim() === "")
+      .map((parts) => parts[2]?.trim() ?? "")
+      .filter((value) => value.length > 0);
+
+    expect(wrappedSummaryLines.length).toBeGreaterThan(0);
+  });
+});

package/tests/runtime/output-mode.test.ts

@@ -0,0 +1,54 @@
+import { decode } from "@toon-format/toon";
+import { describe, expect, test } from "bun:test";
+
+import { okResult, renderResult, toToonEnvelope } from "../../src/io/output";
+import { parseInvocation } from "../../src/runtime/cli-shell";
+
+describe("output mode parsing", (): void => {
+  test("TTY default => human", (): void => {
+    const parsed = parseInvocation(["quickstart"], { stdoutIsTTY: true });
+    expect(parsed.mode).toBe("human");
+  });
+
+  test("non-TTY default => json", (): void => {
+    const parsed = parseInvocation(["quickstart"], { stdoutIsTTY: false });
+    expect(parsed.mode).toBe("json");
+  });
+
+  test("explicit --toon wins", (): void => {
+    const parsed = parseInvocation(["quickstart", "--toon"], { stdoutIsTTY: false });
+    expect(parsed.mode).toBe("toon");
+  });
+
+  test("explicit --json wins", (): void => {
+    const parsed = parseInvocation(["quickstart", "--json"], { stdoutIsTTY: true });
+    expect(parsed.mode).toBe("json");
+  });
+});
+
+describe("output rendering", (): void => {
+  test("renders JSON envelope with --json mode", (): void => {
+    const result = okResult({
+      command: "quickstart",
+      human: "Trekoon quickstart",
+      data: { examples: ["trekoon quickstart --json"] },
+    });
+
+    const jsonOutput = renderResult(result, "json");
+    expect(JSON.parse(jsonOutput)).toEqual(toToonEnvelope(result));
+  });
+
+  test("renders TOON output with --toon mode", (): void => {
+    const result = okResult({
+      command: "sync.status",
+      human: "sync human",
+      data: { branch: "main", conflicts: [] },
+    });
+
+    const toonOutput = renderResult(result, "toon");
+    const jsonOutput = renderResult(result, "json");
+
+    expect(toonOutput).not.toBe(jsonOutput);
+    expect(decode(toonOutput) as unknown).toEqual(toToonEnvelope(result));
+  });
+});

package/tests/storage/database.test.ts

@@ -0,0 +1,91 @@
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+import { afterEach, describe, expect, test } from "bun:test";
+
+import { openTrekoonDatabase } from "../../src/storage/database";
+
+const tempDirs: string[] = [];
+
+function createWorkspace(): string {
+  const workspace: string = mkdtempSync(join(tmpdir(), "trekoon-storage-"));
+  tempDirs.push(workspace);
+  return workspace;
+}
+
+afterEach((): void => {
+  while (tempDirs.length > 0) {
+    const next: string | undefined = tempDirs.pop();
+    if (next) {
+      rmSync(next, { recursive: true, force: true });
+    }
+  }
+});
+
+function tableColumns(db: ReturnType<typeof openTrekoonDatabase>["db"], tableName: string): string[] {
+  const rows = db.query(`PRAGMA table_info(${tableName});`).all() as Array<{ name: string }>;
+  return rows.map((row) => row.name);
+}
+
+describe("storage lifecycle", (): void => {
+  test("creates .trekoon database in current workspace", (): void => {
+    const workspace: string = createWorkspace();
+    const storage = openTrekoonDatabase(workspace);
+
+    try {
+      expect(storage.paths.databaseFile).toBe(join(workspace, ".trekoon", "trekoon.db"));
+
+      const epicsTable = storage.db
+        .query("SELECT name FROM sqlite_master WHERE type='table' AND name='epics';")
+        .get() as { name: string } | null;
+
+      expect(epicsTable?.name).toBe("epics");
+    } finally {
+      storage.close();
+    }
+  });
+
+  test("bootstraps required sync tables", (): void => {
+    const workspace: string = createWorkspace();
+    const storage = openTrekoonDatabase(workspace);
+
+    try {
+      const tables = ["git_context", "sync_cursors", "sync_conflicts"];
+
+      for (const table of tables) {
+        const row = storage.db
+          .query("SELECT name FROM sqlite_master WHERE type='table' AND name=?;")
+          .get(table) as { name: string } | null;
+        expect(row?.name).toBe(table);
+      }
+    } finally {
+      storage.close();
+    }
+  });
+
+  test("tracks updated_at and version for mutable rows", (): void => {
+    const workspace: string = createWorkspace();
+    const storage = openTrekoonDatabase(workspace);
+
+    try {
+      const mutableTables = [
+        "epics",
+        "tasks",
+        "subtasks",
+        "dependencies",
+        "git_context",
+        "sync_cursors",
+        "sync_conflicts",
+      ];
+
+      for (const tableName of mutableTables) {
+        const columns: string[] = tableColumns(storage.db, tableName);
+        expect(columns).toContain("updated_at");
+        expect(columns).toContain("version");
+      }
+    } finally {
+      storage.close();
+    }
+  });
+});

package/tsconfig.json

@@ -0,0 +1,19 @@
+{
+  "compilerOptions": {
+    "target": "ESNext",
+    "module": "ESNext",
+    "moduleResolution": "Bundler",
+    "strict": true,
+    "noUncheckedIndexedAccess": true,
+    "noImplicitOverride": true,
+    "noFallthroughCasesInSwitch": true,
+    "exactOptionalPropertyTypes": true,
+    "forceConsistentCasingInFileNames": true,
+    "allowSyntheticDefaultImports": true,
+    "types": ["bun"],
+    "outDir": "dist",
+    "rootDir": "."
+  },
+  "include": ["src", "tests"],
+  "exclude": ["dist", "trekker", "node_modules"]
+}