@trail-pm/cli 0.1.6 → 0.2.2

package/dist/lib.js

@@ -0,0 +1,669 @@
+// src/core/paths.ts
+import fs from "fs";
+import path from "path";
+var MAX_TRAIL_ROOT_WALK = 20;
+function findTrailRoot(startDir) {
+  let dir = path.resolve(startDir);
+  for (let i = 0; i < MAX_TRAIL_ROOT_WALK; i++) {
+    const configPath = path.join(dir, ".trail", "config.json");
+    if (fs.existsSync(configPath)) {
+      return dir;
+    }
+    const parent = path.dirname(dir);
+    if (parent === dir) {
+      break;
+    }
+    dir = parent;
+  }
+  return null;
+}
+function trailPaths(root) {
+  const trailDir = path.join(root, ".trail");
+  return {
+    root,
+    trailDir,
+    tasksDir: path.join(trailDir, "tasks"),
+    configPath: path.join(trailDir, "config.json"),
+    snapshotPath: path.join(trailDir, "snapshot.json"),
+    gitignorePath: path.join(trailDir, ".gitignore")
+  };
+}
+
+// src/core/task-store.ts
+import fs2 from "fs";
+import path2 from "path";
+
+// src/schemas/task.ts
+import { z } from "zod";
+var TaskStatusSchema = z.enum([
+  "draft",
+  "todo",
+  "in_progress",
+  "in_review",
+  "done",
+  "cancelled"
+]);
+var isoDateStringSchema = z.string().regex(/^\d{4}-\d{2}-\d{2}$/, "Expected ISO date string (YYYY-MM-DD)");
+var TaskGitHubSchema = z.object({
+  issue_number: z.number().int(),
+  synced_at: z.string().datetime({ offset: true }),
+  url: z.string().url()
+}).nullable();
+var TaskAiSchema = z.object({
+  summary: z.string().optional(),
+  acceptance_criteria: z.array(z.string()).optional(),
+  implementation_context: z.array(z.string()).optional(),
+  test_strategy: z.array(z.string()).optional(),
+  constraints: z.array(z.string()).optional()
+}).strict().optional();
+var TaskSchema = z.object({
+  id: z.string(),
+  title: z.string(),
+  description: z.string().optional(),
+  status: TaskStatusSchema,
+  priority: z.enum(["p0", "p1", "p2", "p3"]).optional(),
+  type: z.enum(["feature", "bug", "chore", "epic"]),
+  assignee: z.string().optional(),
+  milestone: z.string().optional(),
+  branch: z.string().optional(),
+  labels: z.array(z.string()).default([]),
+  parent: z.string().nullable().optional(),
+  depends_on: z.array(z.string()).default([]),
+  blocks: z.array(z.string()).default([]),
+  due_date: isoDateStringSchema.optional(),
+  start_date: isoDateStringSchema.optional(),
+  estimate: z.enum(["xs", "sm", "md", "lg", "xl"]).optional(),
+  github: TaskGitHubSchema.optional(),
+  refs: z.array(
+    z.object({
+      type: z.string(),
+      path: z.string()
+    }).strict()
+  ).default([]),
+  ai: TaskAiSchema,
+  created_at: z.string().datetime({ offset: true }),
+  updated_at: z.string().datetime({ offset: true })
+}).strict();
+
+// src/core/task-store.ts
+function toValidationError(zodError, context) {
+  const issues = zodError.issues.map(
+    (i) => `${i.path.length ? i.path.join(".") : "(root)"}: ${i.message}`
+  );
+  return {
+    code: "VALIDATION_FAILED",
+    message: context ? `Task validation failed (${context})` : "Task validation failed",
+    details: zodError.message,
+    issues
+  };
+}
+function throwValidationFailed(err) {
+  const e = new Error(`[VALIDATION_FAILED] ${err.message}`);
+  e.name = "TrailError";
+  e.trailError = err;
+  throw e;
+}
+function listTaskFiles(tasksDir) {
+  const names = fs2.readdirSync(tasksDir);
+  return names.filter(
+    (n) => n.endsWith(".json") && n !== "snapshot.json"
+  ).sort((a, b) => a.localeCompare(b));
+}
+function readTaskFile(filePath) {
+  let raw;
+  try {
+    raw = JSON.parse(fs2.readFileSync(filePath, "utf8"));
+  } catch (e) {
+    if (e instanceof SyntaxError) {
+      throwValidationFailed({
+        code: "VALIDATION_FAILED",
+        message: "Invalid JSON in task file",
+        details: filePath
+      });
+    }
+    throw e;
+  }
+  const parsed = TaskSchema.safeParse(raw);
+  if (!parsed.success) {
+    throwValidationFailed(toValidationError(parsed.error, filePath));
+  }
+  return parsed.data;
+}
+function writeTaskFile(filePath, task) {
+  const parsed = TaskSchema.safeParse(task);
+  if (!parsed.success) {
+    throwValidationFailed(toValidationError(parsed.error, filePath));
+  }
+  const dir = path2.dirname(filePath);
+  fs2.mkdirSync(dir, { recursive: true });
+  const body = `${JSON.stringify(parsed.data, null, 2)}
+`;
+  fs2.writeFileSync(filePath, body, "utf8");
+}
+function loadAllTasks(tasksDir) {
+  if (!fs2.existsSync(tasksDir)) {
+    return [];
+  }
+  const files = listTaskFiles(tasksDir);
+  return files.map((name) => readTaskFile(path2.join(tasksDir, name)));
+}
+function findTaskFileById(tasksDir, id) {
+  if (!fs2.existsSync(tasksDir)) {
+    return null;
+  }
+  const direct = path2.join(tasksDir, `${id}.json`);
+  if (fs2.existsSync(direct)) {
+    const task = readTaskFile(direct);
+    if (task.id === id) {
+      return { filePath: direct, task };
+    }
+  }
+  for (const name of listTaskFiles(tasksDir)) {
+    const filePath = path2.join(tasksDir, name);
+    const task = readTaskFile(filePath);
+    if (task.id === id) {
+      return { filePath, task };
+    }
+  }
+  return null;
+}
+
+// src/core/compile-snapshot.ts
+import fs3 from "fs";
+import path3 from "path";
+
+// src/schemas/snapshot.ts
+import { z as z2 } from "zod";
+var SnapshotSchema = z2.object({
+  generated_at: z2.string().datetime({ offset: true }),
+  tasks: z2.array(TaskSchema),
+  warnings: z2.array(
+    z2.object({
+      code: z2.string(),
+      message: z2.string(),
+      taskId: z2.string().optional()
+    }).strict()
+  )
+}).strict();
+
+// src/core/compile-snapshot.ts
+var UNKNOWN_DEPENDENCY = "UNKNOWN_DEPENDENCY";
+var DEPENDENCY_CYCLE = "DEPENDENCY_CYCLE";
+function detectCycles(taskIds, deps) {
+  const cycles = [];
+  const visited = /* @__PURE__ */ new Set();
+  const visiting = /* @__PURE__ */ new Set();
+  const stack = [];
+  function recordCycle(fromIndex) {
+    cycles.push(stack.slice(fromIndex));
+  }
+  function dfs(u) {
+    visiting.add(u);
+    stack.push(u);
+    for (const v of deps.get(u) ?? []) {
+      if (!taskIds.has(v)) {
+        continue;
+      }
+      if (visiting.has(v)) {
+        const i = stack.indexOf(v);
+        if (i !== -1) {
+          recordCycle(i);
+        }
+        continue;
+      }
+      if (!visited.has(v)) {
+        dfs(v);
+      }
+    }
+    stack.pop();
+    visiting.delete(u);
+    visited.add(u);
+  }
+  for (const id of taskIds) {
+    if (!visited.has(id)) {
+      dfs(id);
+    }
+  }
+  return cycles;
+}
+function formatCycle(nodes) {
+  return nodes.join(" \u2192 ");
+}
+function compileSnapshot(tasks, now) {
+  const generatedAt = (now ?? /* @__PURE__ */ new Date()).toISOString();
+  const taskList = [...tasks];
+  const taskIds = new Set(taskList.map((t) => t.id));
+  const deps = /* @__PURE__ */ new Map();
+  for (const t of taskList) {
+    deps.set(t.id, t.depends_on ?? []);
+  }
+  const warnings = [];
+  for (const t of taskList) {
+    for (const depId of t.depends_on ?? []) {
+      if (!taskIds.has(depId)) {
+        warnings.push({
+          code: UNKNOWN_DEPENDENCY,
+          message: `Task "${t.id}" depends on unknown task id "${depId}"`,
+          taskId: t.id
+        });
+      }
+    }
+  }
+  for (const cycle of detectCycles(taskIds, deps)) {
+    warnings.push({
+      code: DEPENDENCY_CYCLE,
+      message: `Dependency cycle: ${formatCycle(cycle)}`,
+      taskId: cycle[0]
+    });
+  }
+  return {
+    generated_at: generatedAt,
+    tasks: taskList,
+    warnings
+  };
+}
+function writeSnapshot(snapshotPath, snapshot) {
+  const parsed = SnapshotSchema.parse(snapshot);
+  const dir = path3.dirname(snapshotPath);
+  fs3.mkdirSync(dir, { recursive: true });
+  const body = `${JSON.stringify(parsed, null, 2)}
+`;
+  fs3.writeFileSync(snapshotPath, body, "utf8");
+}
+
+// src/core/rebuild-snapshot.ts
+function rebuildSnapshot(paths, now = /* @__PURE__ */ new Date()) {
+  const tasks = loadAllTasks(paths.tasksDir);
+  const snapshot = compileSnapshot(tasks, now);
+  writeSnapshot(paths.snapshotPath, snapshot);
+}
+
+// src/core/draft-id.ts
+import { randomBytes } from "crypto";
+function generateDraftId() {
+  return `draft-${randomBytes(4).toString("hex")}`;
+}
+
+// src/schemas/config.ts
+import { z as z3 } from "zod";
+var TrailConfigSchema = z3.object({
+  github: z3.object({
+    owner: z3.string(),
+    repo: z3.string()
+  }).strict(),
+  sync: z3.object({
+    preset: z3.enum(["collaborative", "solo", "offline"]),
+    auto_sync_on_command: z3.boolean(),
+    ui_poll_interval_seconds: z3.number(),
+    ui_idle_backoff: z3.boolean()
+  }).strict(),
+  /** Last successful full sync; useful for future `trail status` and similar. */
+  last_full_sync_at: z3.string().datetime({ offset: true }).optional()
+}).strict();
+
+// src/core/auth.ts
+import * as childProcess from "child_process";
+var AUTH_HINT = "Set GITHUB_TOKEN or install gh and run gh auth login";
+function authRequired(message) {
+  return {
+    ok: false,
+    error: {
+      code: "AUTH_REQUIRED",
+      message,
+      hint: AUTH_HINT
+    }
+  };
+}
+function resolveGitHubToken(env) {
+  const e = env ?? process.env;
+  const fromEnv = e.GITHUB_TOKEN;
+  if (typeof fromEnv === "string" && fromEnv.trim() !== "") {
+    return { ok: true, token: fromEnv.trim() };
+  }
+  try {
+    const out = childProcess.execFileSync("gh", ["auth", "token"], {
+      encoding: "utf-8"
+    });
+    const token = out.trim();
+    if (token === "") {
+      return authRequired("GitHub CLI returned an empty token");
+    }
+    return { ok: true, token };
+  } catch {
+    return authRequired(
+      "No GitHub token found; could not read from environment or gh CLI"
+    );
+  }
+}
+
+// src/core/github-client.ts
+var USER_AGENT = "trail-cli/0.0.1";
+function normalizeBaseUrl(baseUrl) {
+  return baseUrl.replace(/\/$/, "");
+}
+var GitHubClient = class {
+  token;
+  baseUrl;
+  constructor(token, baseUrl = "https://api.github.com") {
+    this.token = token;
+    this.baseUrl = normalizeBaseUrl(baseUrl);
+  }
+  async request(method, path6, body) {
+    const url = `${this.baseUrl}${path6.startsWith("/") ? path6 : `/${path6}`}`;
+    const headers = new Headers({
+      Authorization: `Bearer ${this.token}`,
+      Accept: "application/vnd.github+json",
+      "X-GitHub-Api-Version": "2022-11-28",
+      "User-Agent": USER_AGENT
+    });
+    if (body !== void 0) {
+      headers.set("Content-Type", "application/json");
+    }
+    return fetch(url, {
+      method,
+      headers,
+      body: body !== void 0 ? JSON.stringify(body) : void 0
+    });
+  }
+  async parseJson(response) {
+    const text = await response.text();
+    if (!response.ok) {
+      const snippet = text.slice(0, 200);
+      throw new Error(`GitHub API ${response.status}: ${snippet}`);
+    }
+    return JSON.parse(text);
+  }
+  async listIssues(owner, repo, params) {
+    const search = new URLSearchParams({
+      state: params.state,
+      per_page: String(params.per_page),
+      page: String(params.page)
+    });
+    const path6 = `/repos/${encodeURIComponent(owner)}/${encodeURIComponent(repo)}/issues?${search}`;
+    const response = await this.request("GET", path6);
+    return this.parseJson(response);
+  }
+  async getIssue(owner, repo, issueNumber) {
+    const path6 = `/repos/${encodeURIComponent(owner)}/${encodeURIComponent(repo)}/issues/${issueNumber}`;
+    const response = await this.request("GET", path6);
+    return this.parseJson(response);
+  }
+  async updateIssue(owner, repo, issueNumber, patch) {
+    const path6 = `/repos/${encodeURIComponent(owner)}/${encodeURIComponent(repo)}/issues/${issueNumber}`;
+    const response = await this.request("PATCH", path6, patch);
+    return this.parseJson(response);
+  }
+  async createIssueComment(owner, repo, issueNumber, body) {
+    const path6 = `/repos/${encodeURIComponent(owner)}/${encodeURIComponent(repo)}/issues/${issueNumber}/comments`;
+    const response = await this.request("POST", path6, { body });
+    return this.parseJson(response);
+  }
+  /** Create a new issue. Returns the created issue (same shape as list/get). */
+  async createIssue(owner, repo, input) {
+    const path6 = `/repos/${encodeURIComponent(owner)}/${encodeURIComponent(repo)}/issues`;
+    const response = await this.request("POST", path6, {
+      title: input.title,
+      body: input.body ?? "",
+      labels: input.labels ?? []
+    });
+    return this.parseJson(response);
+  }
+};
+
+// src/core/github-mapper.ts
+function statusFromIssue(issue, existing) {
+  if (issue.state === "closed") {
+    return "done";
+  }
+  const prev = existing?.status;
+  if (prev === "in_progress" || prev === "in_review") {
+    return prev;
+  }
+  return "todo";
+}
+function parseIssueTimestamp(issue, fallback) {
+  if (issue.updated_at.trim() === "") {
+    return fallback.toISOString();
+  }
+  return issue.updated_at;
+}
+function issueToTask(issue, existing, now) {
+  const updatedAt = parseIssueTimestamp(issue, now);
+  const createdAt = existing?.created_at ?? (issue.updated_at.trim() !== "" ? issue.updated_at : now.toISOString());
+  const raw = {
+    id: String(issue.number),
+    title: issue.title,
+    description: issue.body ?? "",
+    status: statusFromIssue(issue, existing),
+    type: existing?.type ?? "feature",
+    labels: issue.labels.map((l) => l.name),
+    assignee: issue.assignee?.login,
+    milestone: issue.milestone?.title,
+    depends_on: existing?.depends_on ?? [],
+    blocks: existing?.blocks ?? [],
+    refs: existing?.refs ?? [],
+    ai: existing?.ai,
+    branch: existing?.branch,
+    estimate: existing?.estimate,
+    priority: existing?.priority,
+    parent: existing?.parent,
+    due_date: existing?.due_date,
+    start_date: existing?.start_date,
+    github: {
+      issue_number: issue.number,
+      synced_at: now.toISOString(),
+      url: issue.html_url
+    },
+    created_at: createdAt,
+    updated_at: updatedAt
+  };
+  return TaskSchema.parse(raw);
+}
+function taskToIssueUpdate(task) {
+  const labels = [...task.labels];
+  if (task.priority) {
+    const priorityLabel = `priority:${task.priority}`;
+    if (!labels.includes(priorityLabel)) {
+      labels.push(priorityLabel);
+    }
+  }
+  const state = task.status === "done" || task.status === "cancelled" ? "closed" : "open";
+  return {
+    title: task.title,
+    body: task.description ?? "",
+    state,
+    labels
+  };
+}
+
+// src/core/sync.ts
+import fs4 from "fs";
+import path4 from "path";
+
+// src/core/relevant-tasks.ts
+var NON_TERMINAL = [
+  "draft",
+  "todo",
+  "in_progress",
+  "in_review"
+];
+function isNonTerminalStatus(status) {
+  return NON_TERMINAL.includes(status);
+}
+function isActiveForRelevance(task) {
+  return isNonTerminalStatus(task.status);
+}
+function computeRelevantTaskIds(tasks) {
+  const byId = /* @__PURE__ */ new Map();
+  for (const t of tasks) {
+    byId.set(t.id, t);
+  }
+  const relevant = /* @__PURE__ */ new Set();
+  const queue = [];
+  for (const t of tasks) {
+    if (isActiveForRelevance(t)) {
+      if (!relevant.has(t.id)) {
+        relevant.add(t.id);
+        queue.push(t.id);
+      }
+    }
+  }
+  function enqueue(id) {
+    if (relevant.has(id)) return;
+    relevant.add(id);
+    queue.push(id);
+  }
+  while (queue.length > 0) {
+    const id = queue.pop();
+    const task = byId.get(id);
+    if (!task) continue;
+    for (const d of task.depends_on) {
+      if (byId.has(d)) enqueue(d);
+    }
+    for (const b of task.blocks) {
+      if (byId.has(b)) enqueue(b);
+    }
+    if (task.parent != null && task.parent !== "" && byId.has(task.parent)) {
+      enqueue(task.parent);
+    }
+  }
+  return relevant;
+}
+
+// src/core/sync.ts
+var ISSUES_PER_PAGE = 100;
+async function pullSync(options) {
+  const { client, owner, repo, tasksDir } = options;
+  const now = options.now ?? /* @__PURE__ */ new Date();
+  const onProgress = options.onProgress;
+  let page = 1;
+  let issuesSoFar = 0;
+  for (; ; ) {
+    const issues = await client.listIssues(owner, repo, {
+      state: "all",
+      per_page: ISSUES_PER_PAGE,
+      page
+    });
+    if (issues.length === 0) {
+      break;
+    }
+    for (const issue of issues) {
+      const filePath = path4.join(tasksDir, `${issue.number}.json`);
+      let existing = null;
+      if (fs4.existsSync(filePath)) {
+        existing = readTaskFile(filePath);
+      }
+      const task = issueToTask(issue, existing, now);
+      writeTaskFile(filePath, task);
+    }
+    issuesSoFar += issues.length;
+    onProgress?.({
+      phase: "pull",
+      page,
+      issuesInPage: issues.length,
+      issuesSoFar
+    });
+    if (issues.length < ISSUES_PER_PAGE) {
+      break;
+    }
+    page += 1;
+  }
+}
+function isLinkedTask(task) {
+  return task.github != null && typeof task.github === "object";
+}
+async function pushSync(options) {
+  const { client, owner, repo, tasks } = options;
+  const only = options.onlyTaskIds;
+  const onProgress = options.onProgress;
+  const toPush = tasks.filter((task) => {
+    if (task.status === "draft") {
+      return false;
+    }
+    if (!isLinkedTask(task)) {
+      return false;
+    }
+    if (only !== void 0 && !only.has(task.id)) {
+      return false;
+    }
+    return true;
+  });
+  let index = 0;
+  for (const task of toPush) {
+    if (!isLinkedTask(task)) {
+      continue;
+    }
+    index += 1;
+    onProgress?.({
+      phase: "push",
+      index,
+      total: toPush.length,
+      taskId: task.id
+    });
+    const patch = taskToIssueUpdate(task);
+    await client.updateIssue(owner, repo, task.github.issue_number, patch);
+  }
+}
+async function fullSync(options) {
+  const { client, owner, repo, tasksDir, snapshotPath, now } = options;
+  await pullSync({ client, owner, repo, tasksDir, now, onProgress: options.onProgress });
+  const tasks = loadAllTasks(tasksDir);
+  const relevant = computeRelevantTaskIds(tasks);
+  await pushSync({
+    client,
+    owner,
+    repo,
+    tasks,
+    onlyTaskIds: relevant,
+    onProgress: options.onProgress
+  });
+  const snapshot = compileSnapshot(tasks, now);
+  writeSnapshot(snapshotPath, snapshot);
+}
+
+// src/core/config-update.ts
+import fs5 from "fs";
+function writeLastFullSyncAt(paths, iso) {
+  const raw = fs5.readFileSync(paths.configPath, "utf-8");
+  const config = TrailConfigSchema.parse(JSON.parse(raw));
+  const next = { ...config, last_full_sync_at: iso };
+  fs5.writeFileSync(paths.configPath, `${JSON.stringify(next, null, 2)}
+`, "utf-8");
+}
+
+// src/core/link-draft-issue.ts
+import fs6 from "fs";
+import path5 from "path";
+async function linkDraftToNewGitHubIssue(options) {
+  const { client, owner, repo, draft, draftFilePath, tasksDir, now } = options;
+  const issue = await client.createIssue(owner, repo, {
+    title: draft.title,
+    body: draft.description ?? "",
+    labels: draft.labels
+  });
+  const promoted = issueToTask(issue, draft, now);
+  fs6.unlinkSync(draftFilePath);
+  const newPath = path5.join(tasksDir, `${issue.number}.json`);
+  writeTaskFile(newPath, promoted);
+  return promoted;
+}
+export {
+  GitHubClient,
+  TaskSchema,
+  TrailConfigSchema,
+  findTaskFileById,
+  findTrailRoot,
+  fullSync,
+  generateDraftId,
+  issueToTask,
+  linkDraftToNewGitHubIssue,
+  loadAllTasks,
+  pullSync,
+  rebuildSnapshot,
+  resolveGitHubToken,
+  taskToIssueUpdate,
+  trailPaths,
+  writeLastFullSyncAt,
+  writeTaskFile
+};
+//# sourceMappingURL=lib.js.map