@obsfx/trekker 0.1.5

package/dist/index.js

@@ -0,0 +1,2278 @@
+#!/usr/bin/env bun
+// @bun
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+
+// src/index.ts
+import { Command as Command11 } from "commander";
+
+// src/commands/init.ts
+import { Command } from "commander";
+
+// src/db/client.ts
+import { Database } from "bun:sqlite";
+import { drizzle } from "drizzle-orm/bun-sqlite";
+
+// src/db/schema.ts
+var exports_schema = {};
+__export(exports_schema, {
+  tasksRelations: () => tasksRelations,
+  tasks: () => tasks,
+  projectsRelations: () => projectsRelations,
+  projects: () => projects,
+  idCounters: () => idCounters,
+  epicsRelations: () => epicsRelations,
+  epics: () => epics,
+  dependenciesRelations: () => dependenciesRelations,
+  dependencies: () => dependencies,
+  commentsRelations: () => commentsRelations,
+  comments: () => comments
+});
+import { relations } from "drizzle-orm";
+
+// ../shared/schema.ts
+import { sqliteTable, text, integer } from "drizzle-orm/sqlite-core";
+var projects = sqliteTable("projects", {
+  id: text("id").primaryKey(),
+  name: text("name").notNull().unique(),
+  createdAt: integer("created_at", { mode: "timestamp" }).notNull(),
+  updatedAt: integer("updated_at", { mode: "timestamp" }).notNull()
+});
+var epics = sqliteTable("epics", {
+  id: text("id").primaryKey(),
+  projectId: text("project_id").notNull(),
+  title: text("title").notNull(),
+  description: text("description"),
+  status: text("status").notNull().default("todo"),
+  priority: integer("priority").notNull().default(2),
+  createdAt: integer("created_at", { mode: "timestamp" }).notNull(),
+  updatedAt: integer("updated_at", { mode: "timestamp" }).notNull()
+});
+var tasks = sqliteTable("tasks", {
+  id: text("id").primaryKey(),
+  projectId: text("project_id").notNull(),
+  epicId: text("epic_id"),
+  parentTaskId: text("parent_task_id"),
+  title: text("title").notNull(),
+  description: text("description"),
+  priority: integer("priority").notNull().default(2),
+  status: text("status").notNull().default("todo"),
+  tags: text("tags"),
+  createdAt: integer("created_at", { mode: "timestamp" }).notNull(),
+  updatedAt: integer("updated_at", { mode: "timestamp" }).notNull()
+});
+var comments = sqliteTable("comments", {
+  id: text("id").primaryKey(),
+  taskId: text("task_id").notNull(),
+  author: text("author").notNull(),
+  content: text("content").notNull(),
+  createdAt: integer("created_at", { mode: "timestamp" }).notNull(),
+  updatedAt: integer("updated_at", { mode: "timestamp" }).notNull()
+});
+var dependencies = sqliteTable("dependencies", {
+  id: text("id").primaryKey(),
+  taskId: text("task_id").notNull(),
+  dependsOnId: text("depends_on_id").notNull(),
+  createdAt: integer("created_at", { mode: "timestamp" }).notNull()
+});
+var idCounters = sqliteTable("id_counters", {
+  entityType: text("entity_type").primaryKey(),
+  counter: integer("counter").notNull().default(0)
+});
+// ../shared/types.ts
+var TASK_STATUSES = [
+  "todo",
+  "in_progress",
+  "completed",
+  "wont_fix",
+  "archived"
+];
+var EPIC_STATUSES = [
+  "todo",
+  "in_progress",
+  "completed",
+  "archived"
+];
+var PREFIX_MAP = {
+  task: "TREK",
+  epic: "EPIC",
+  comment: "CMT"
+};
+// src/db/schema.ts
+var projectsRelations = relations(projects, ({ many }) => ({
+  epics: many(epics),
+  tasks: many(tasks)
+}));
+var epicsRelations = relations(epics, ({ one, many }) => ({
+  project: one(projects, {
+    fields: [epics.projectId],
+    references: [projects.id]
+  }),
+  tasks: many(tasks)
+}));
+var tasksRelations = relations(tasks, ({ one, many }) => ({
+  project: one(projects, {
+    fields: [tasks.projectId],
+    references: [projects.id]
+  }),
+  epic: one(epics, {
+    fields: [tasks.epicId],
+    references: [epics.id]
+  }),
+  parentTask: one(tasks, {
+    fields: [tasks.parentTaskId],
+    references: [tasks.id],
+    relationName: "subtasks"
+  }),
+  subtasks: many(tasks, { relationName: "subtasks" }),
+  comments: many(comments),
+  dependsOn: many(dependencies, { relationName: "dependsOn" }),
+  blockedBy: many(dependencies, { relationName: "blockedBy" })
+}));
+var commentsRelations = relations(comments, ({ one }) => ({
+  task: one(tasks, {
+    fields: [comments.taskId],
+    references: [tasks.id]
+  })
+}));
+var dependenciesRelations = relations(dependencies, ({ one }) => ({
+  task: one(tasks, {
+    fields: [dependencies.taskId],
+    references: [tasks.id],
+    relationName: "dependsOn"
+  }),
+  dependsOn: one(tasks, {
+    fields: [dependencies.dependsOnId],
+    references: [tasks.id],
+    relationName: "blockedBy"
+  })
+}));
+
+// src/db/client.ts
+import { existsSync, mkdirSync, rmSync } from "fs";
+import { join } from "path";
+var TREKKER_DIR = ".trekker";
+var DB_NAME = "trekker.db";
+function getTrekkerDir(cwd = process.cwd()) {
+  return join(cwd, TREKKER_DIR);
+}
+function getDbPath(cwd = process.cwd()) {
+  return join(getTrekkerDir(cwd), DB_NAME);
+}
+function isTrekkerInitialized(cwd = process.cwd()) {
+  return existsSync(getDbPath(cwd));
+}
+function ensureTrekkerDir(cwd = process.cwd()) {
+  const trekkerDir = getTrekkerDir(cwd);
+  if (!existsSync(trekkerDir)) {
+    mkdirSync(trekkerDir, { recursive: true });
+  }
+}
+var dbInstance = null;
+var sqliteInstance = null;
+function getDb(cwd = process.cwd()) {
+  if (dbInstance) {
+    return dbInstance;
+  }
+  const dbPath = getDbPath(cwd);
+  if (!existsSync(dbPath)) {
+    throw new Error("Trekker not initialized. Run 'trekker init' first.");
+  }
+  sqliteInstance = new Database(dbPath);
+  dbInstance = drizzle(sqliteInstance, { schema: exports_schema });
+  return dbInstance;
+}
+function createDb(cwd = process.cwd()) {
+  ensureTrekkerDir(cwd);
+  const dbPath = getDbPath(cwd);
+  sqliteInstance = new Database(dbPath);
+  dbInstance = drizzle(sqliteInstance, { schema: exports_schema });
+  sqliteInstance.exec(`
+    CREATE TABLE IF NOT EXISTS projects (
+      id TEXT PRIMARY KEY,
+      name TEXT NOT NULL UNIQUE,
+      created_at INTEGER NOT NULL,
+      updated_at INTEGER NOT NULL
+    );
+
+    CREATE TABLE IF NOT EXISTS epics (
+      id TEXT PRIMARY KEY,
+      project_id TEXT NOT NULL REFERENCES projects(id) ON DELETE CASCADE,
+      title TEXT NOT NULL,
+      description TEXT,
+      status TEXT NOT NULL DEFAULT 'todo',
+      priority INTEGER NOT NULL DEFAULT 2,
+      created_at INTEGER NOT NULL,
+      updated_at INTEGER NOT NULL
+    );
+
+    CREATE TABLE IF NOT EXISTS tasks (
+      id TEXT PRIMARY KEY,
+      project_id TEXT NOT NULL REFERENCES projects(id) ON DELETE CASCADE,
+      epic_id TEXT REFERENCES epics(id) ON DELETE SET NULL,
+      parent_task_id TEXT,
+      title TEXT NOT NULL,
+      description TEXT,
+      priority INTEGER NOT NULL DEFAULT 2,
+      status TEXT NOT NULL DEFAULT 'todo',
+      tags TEXT,
+      created_at INTEGER NOT NULL,
+      updated_at INTEGER NOT NULL
+    );
+
+    CREATE TABLE IF NOT EXISTS comments (
+      id TEXT PRIMARY KEY,
+      task_id TEXT NOT NULL REFERENCES tasks(id) ON DELETE CASCADE,
+      author TEXT NOT NULL,
+      content TEXT NOT NULL,
+      created_at INTEGER NOT NULL,
+      updated_at INTEGER NOT NULL
+    );
+
+    CREATE TABLE IF NOT EXISTS dependencies (
+      id TEXT PRIMARY KEY,
+      task_id TEXT NOT NULL REFERENCES tasks(id) ON DELETE CASCADE,
+      depends_on_id TEXT NOT NULL REFERENCES tasks(id) ON DELETE CASCADE,
+      created_at INTEGER NOT NULL
+    );
+
+    CREATE TABLE IF NOT EXISTS id_counters (
+      entity_type TEXT PRIMARY KEY,
+      counter INTEGER NOT NULL DEFAULT 0
+    );
+
+    -- Initialize counters
+    INSERT OR IGNORE INTO id_counters (entity_type, counter) VALUES ('task', 0);
+    INSERT OR IGNORE INTO id_counters (entity_type, counter) VALUES ('epic', 0);
+    INSERT OR IGNORE INTO id_counters (entity_type, counter) VALUES ('comment', 0);
+  `);
+  return dbInstance;
+}
+function closeDb() {
+  if (sqliteInstance) {
+    sqliteInstance.close();
+    sqliteInstance = null;
+    dbInstance = null;
+  }
+}
+function deleteDb(cwd = process.cwd()) {
+  closeDb();
+  const trekkerDir = getTrekkerDir(cwd);
+  if (existsSync(trekkerDir)) {
+    rmSync(trekkerDir, { recursive: true, force: true });
+  }
+}
+
+// src/utils/id-generator.ts
+import { eq, sql } from "drizzle-orm";
+function generateId(entityType) {
+  const db = getDb();
+  const prefix = PREFIX_MAP[entityType];
+  db.update(idCounters).set({ counter: sql`${idCounters.counter} + 1` }).where(eq(idCounters.entityType, entityType)).run();
+  const result = db.select({ counter: idCounters.counter }).from(idCounters).where(eq(idCounters.entityType, entityType)).get();
+  if (!result) {
+    throw new Error(`Counter not found for entity type: ${entityType}`);
+  }
+  return `${prefix}-${result.counter}`;
+}
+function generateUuid() {
+  return crypto.randomUUID();
+}
+
+// src/services/project.ts
+import { basename } from "path";
+function initProject(cwd = process.cwd()) {
+  if (isTrekkerInitialized(cwd)) {
+    throw new Error("Trekker is already initialized in this directory.");
+  }
+  const db = createDb(cwd);
+  const projectName = basename(cwd);
+  const now = new Date;
+  db.insert(projects).values({
+    id: generateUuid(),
+    name: projectName,
+    createdAt: now,
+    updatedAt: now
+  }).run();
+}
+function wipeProject(cwd = process.cwd()) {
+  if (!isTrekkerInitialized(cwd)) {
+    throw new Error("Trekker is not initialized in this directory.");
+  }
+  deleteDb(cwd);
+}
+
+// src/utils/output.ts
+var jsonMode = false;
+function setJsonMode(enabled) {
+  jsonMode = enabled;
+}
+function isJsonMode() {
+  return jsonMode;
+}
+function output(data) {
+  if (jsonMode) {
+    console.log(JSON.stringify(data, null, 2));
+  } else if (typeof data === "string") {
+    console.log(data);
+  } else {
+    console.log(JSON.stringify(data, null, 2));
+  }
+}
+function success(message, data) {
+  if (jsonMode) {
+    console.log(JSON.stringify({ success: true, message, data }, null, 2));
+  } else {
+    console.log(`\u2713 ${message}`);
+    if (data) {
+      output(data);
+    }
+  }
+}
+function error(message, details) {
+  if (jsonMode) {
+    console.error(JSON.stringify({ success: false, error: message, details }, null, 2));
+  } else {
+    console.error(`\u2717 Error: ${message}`);
+    if (details) {
+      console.error(details);
+    }
+  }
+}
+function info(message) {
+  if (!jsonMode) {
+    console.log(message);
+  }
+}
+function formatTask(task) {
+  const lines = [
+    `ID:          ${task.id}`,
+    `Title:       ${task.title}`,
+    `Status:      ${task.status}`,
+    `Priority:    ${task.priority}`
+  ];
+  if (task.description) {
+    lines.push(`Description: ${task.description}`);
+  }
+  if (task.epicId) {
+    lines.push(`Epic:        ${task.epicId}`);
+  }
+  if (task.parentTaskId) {
+    lines.push(`Parent:      ${task.parentTaskId}`);
+  }
+  if (task.tags) {
+    lines.push(`Tags:        ${task.tags}`);
+  }
+  lines.push(`Created:     ${task.createdAt.toISOString()}`);
+  lines.push(`Updated:     ${task.updatedAt.toISOString()}`);
+  return lines.join(`
+`);
+}
+function formatEpic(epic) {
+  const lines = [
+    `ID:          ${epic.id}`,
+    `Title:       ${epic.title}`,
+    `Status:      ${epic.status}`,
+    `Priority:    ${epic.priority}`
+  ];
+  if (epic.description) {
+    lines.push(`Description: ${epic.description}`);
+  }
+  lines.push(`Created:     ${epic.createdAt.toISOString()}`);
+  lines.push(`Updated:     ${epic.updatedAt.toISOString()}`);
+  return lines.join(`
+`);
+}
+function formatComment(comment) {
+  const lines = [
+    `ID:      ${comment.id}`,
+    `Author:  ${comment.author}`,
+    `Content: ${comment.content}`,
+    `Created: ${comment.createdAt.toISOString()}`
+  ];
+  return lines.join(`
+`);
+}
+function formatTaskList(tasks2) {
+  if (tasks2.length === 0) {
+    return "No tasks found.";
+  }
+  const lines = tasks2.map((task) => {
+    const tags = task.tags ? ` [${task.tags}]` : "";
+    const parent = task.parentTaskId ? ` (subtask of ${task.parentTaskId})` : "";
+    return `${task.id} | ${task.status.padEnd(11)} | P${task.priority} | ${task.title}${tags}${parent}`;
+  });
+  return lines.join(`
+`);
+}
+function formatEpicList(epics2) {
+  if (epics2.length === 0) {
+    return "No epics found.";
+  }
+  const lines = epics2.map((epic) => {
+    return `${epic.id} | ${epic.status.padEnd(11)} | P${epic.priority} | ${epic.title}`;
+  });
+  return lines.join(`
+`);
+}
+function formatCommentList(comments2) {
+  if (comments2.length === 0) {
+    return "No comments found.";
+  }
+  return comments2.map((c) => `[${c.id}] ${c.author}: ${c.content}`).join(`
+`);
+}
+function formatDependencyList(dependencies2, direction) {
+  if (dependencies2.length === 0) {
+    return direction === "depends_on" ? "No dependencies." : "Does not block any tasks.";
+  }
+  if (direction === "depends_on") {
+    return dependencies2.map((d) => `  \u2192 depends on ${d.dependsOnId}`).join(`
+`);
+  } else {
+    return dependencies2.map((d) => `  \u2192 blocks ${d.taskId}`).join(`
+`);
+  }
+}
+
+// src/commands/init.ts
+var initCommand = new Command("init").description("Initialize Trekker in the current directory").action(() => {
+  try {
+    if (isTrekkerInitialized()) {
+      error("Trekker is already initialized in this directory.");
+      process.exit(1);
+    }
+    initProject();
+    success("Trekker initialized successfully.");
+  } catch (err) {
+    error(err instanceof Error ? err.message : String(err));
+    process.exit(1);
+  }
+});
+
+// src/commands/wipe.ts
+import { Command as Command2 } from "commander";
+import * as readline from "readline";
+var wipeCommand = new Command2("wipe").description("Delete all Trekker data in the current directory").option("-y, --yes", "Skip confirmation prompt").action(async (options) => {
+  try {
+    if (!isTrekkerInitialized()) {
+      error("Trekker is not initialized in this directory.");
+      process.exit(1);
+    }
+    if (!options.yes) {
+      const confirmed = await confirm("Are you sure you want to delete all Trekker data? This cannot be undone. (y/N): ");
+      if (!confirmed) {
+        console.log("Aborted.");
+        return;
+      }
+    }
+    wipeProject();
+    success("Trekker data deleted successfully.");
+  } catch (err) {
+    error(err instanceof Error ? err.message : String(err));
+    process.exit(1);
+  }
+});
+function confirm(prompt) {
+  return new Promise((resolve) => {
+    const rl = readline.createInterface({
+      input: process.stdin,
+      output: process.stdout
+    });
+    rl.question(prompt, (answer) => {
+      rl.close();
+      resolve(answer.toLowerCase() === "y" || answer.toLowerCase() === "yes");
+    });
+  });
+}
+
+// src/commands/epic.ts
+import { Command as Command3 } from "commander";
+
+// src/services/epic.ts
+import { eq as eq2 } from "drizzle-orm";
+function createEpic(input) {
+  const db = getDb();
+  const project = db.select().from(projects).get();
+  if (!project) {
+    throw new Error("Project not found. Run 'trekker init' first.");
+  }
+  const id = generateId("epic");
+  const now = new Date;
+  const epic = {
+    id,
+    projectId: project.id,
+    title: input.title,
+    description: input.description ?? null,
+    status: input.status ?? "todo",
+    priority: input.priority ?? 2,
+    createdAt: now,
+    updatedAt: now
+  };
+  db.insert(epics).values(epic).run();
+  return epic;
+}
+function getEpic(id) {
+  const db = getDb();
+  const result = db.select().from(epics).where(eq2(epics.id, id)).get();
+  return result;
+}
+function listEpics(status) {
+  const db = getDb();
+  if (status) {
+    return db.select().from(epics).where(eq2(epics.status, status)).all();
+  }
+  return db.select().from(epics).all();
+}
+function updateEpic(id, input) {
+  const db = getDb();
+  const existing = getEpic(id);
+  if (!existing) {
+    throw new Error(`Epic not found: ${id}`);
+  }
+  const updates = {
+    updatedAt: new Date
+  };
+  if (input.title !== undefined)
+    updates.title = input.title;
+  if (input.description !== undefined)
+    updates.description = input.description;
+  if (input.status !== undefined)
+    updates.status = input.status;
+  if (input.priority !== undefined)
+    updates.priority = input.priority;
+  db.update(epics).set(updates).where(eq2(epics.id, id)).run();
+  return getEpic(id);
+}
+function deleteEpic(id) {
+  const db = getDb();
+  const existing = getEpic(id);
+  if (!existing) {
+    throw new Error(`Epic not found: ${id}`);
+  }
+  db.delete(epics).where(eq2(epics.id, id)).run();
+}
+// src/utils/validator.ts
+function isValidTaskStatus(status) {
+  return TASK_STATUSES.includes(status);
+}
+function isValidEpicStatus(status) {
+  return EPIC_STATUSES.includes(status);
+}
+function isValidPriority(priority) {
+  return Number.isInteger(priority) && priority >= 0 && priority <= 5;
+}
+function parseStatus(status, type) {
+  if (!status)
+    return;
+  const normalizedStatus = status.toLowerCase().replace(/-/g, "_");
+  if (type === "task") {
+    if (!isValidTaskStatus(normalizedStatus)) {
+      throw new Error(`Invalid task status: ${status}. Valid values: ${TASK_STATUSES.join(", ")}`);
+    }
+    return normalizedStatus;
+  } else {
+    if (!isValidEpicStatus(normalizedStatus)) {
+      throw new Error(`Invalid epic status: ${status}. Valid values: ${EPIC_STATUSES.join(", ")}`);
+    }
+    return normalizedStatus;
+  }
+}
+function parsePriority(priority) {
+  if (priority === undefined)
+    return;
+  const num = parseInt(priority, 10);
+  if (isNaN(num) || !isValidPriority(num)) {
+    throw new Error(`Invalid priority: ${priority}. Must be a number between 0 and 5.`);
+  }
+  return num;
+}
+function validateRequired(value, fieldName) {
+  if (value === undefined || value === null || value === "") {
+    throw new Error(`${fieldName} is required`);
+  }
+}
+
+// src/commands/epic.ts
+var epicCommand = new Command3("epic").description("Manage epics");
+epicCommand.command("create").description("Create a new epic").requiredOption("-t, --title <title>", "Epic title").option("-d, --description <description>", "Epic description").option("-p, --priority <priority>", "Priority (0-5, default: 2)").option("-s, --status <status>", "Status (todo, in_progress, completed, archived)").action((options) => {
+  try {
+    validateRequired(options.title, "Title");
+    const epic = createEpic({
+      title: options.title,
+      description: options.description,
+      priority: parsePriority(options.priority),
+      status: parseStatus(options.status, "epic")
+    });
+    if (isJsonMode()) {
+      output(epic);
+    } else {
+      success(`Epic created: ${epic.id}`);
+      console.log(formatEpic(epic));
+    }
+  } catch (err) {
+    error(err instanceof Error ? err.message : String(err));
+    process.exit(1);
+  }
+});
+epicCommand.command("list").description("List all epics").option("-s, --status <status>", "Filter by status").action((options) => {
+  try {
+    const status = parseStatus(options.status, "epic");
+    const epics2 = listEpics(status);
+    if (isJsonMode()) {
+      output(epics2);
+    } else {
+      console.log(formatEpicList(epics2));
+    }
+  } catch (err) {
+    error(err instanceof Error ? err.message : String(err));
+    process.exit(1);
+  }
+});
+epicCommand.command("show <epic-id>").description("Show epic details").action((epicId) => {
+  try {
+    const epic = getEpic(epicId);
+    if (!epic) {
+      error(`Epic not found: ${epicId}`);
+      process.exit(1);
+    }
+    if (isJsonMode()) {
+      output(epic);
+    } else {
+      console.log(formatEpic(epic));
+    }
+  } catch (err) {
+    error(err instanceof Error ? err.message : String(err));
+    process.exit(1);
+  }
+});
+epicCommand.command("update <epic-id>").description("Update an epic").option("-t, --title <title>", "New title").option("-d, --description <description>", "New description").option("-p, --priority <priority>", "New priority (0-5)").option("-s, --status <status>", "New status").action((epicId, options) => {
+  try {
+    const epic = updateEpic(epicId, {
+      title: options.title,
+      description: options.description,
+      priority: parsePriority(options.priority),
+      status: parseStatus(options.status, "epic")
+    });
+    if (isJsonMode()) {
+      output(epic);
+    } else {
+      success(`Epic updated: ${epic.id}`);
+      console.log(formatEpic(epic));
+    }
+  } catch (err) {
+    error(err instanceof Error ? err.message : String(err));
+    process.exit(1);
+  }
+});
+epicCommand.command("delete <epic-id>").description("Delete an epic").action((epicId) => {
+  try {
+    deleteEpic(epicId);
+    success(`Epic deleted: ${epicId}`);
+  } catch (err) {
+    error(err instanceof Error ? err.message : String(err));
+    process.exit(1);
+  }
+});
+
+// src/commands/task.ts
+import { Command as Command4 } from "commander";
+
+// src/services/task.ts
+import { eq as eq3, and, isNull } from "drizzle-orm";
+function createTask(input) {
+  const db = getDb();
+  const project = db.select().from(projects).get();
+  if (!project) {
+    throw new Error("Project not found. Run 'trekker init' first.");
+  }
+  if (input.epicId) {
+    const epic = db.select().from(epics).where(eq3(epics.id, input.epicId)).get();
+    if (!epic) {
+      throw new Error(`Epic not found: ${input.epicId}`);
+    }
+  }
+  if (input.parentTaskId) {
+    const parent = db.select().from(tasks).where(eq3(tasks.id, input.parentTaskId)).get();
+    if (!parent) {
+      throw new Error(`Parent task not found: ${input.parentTaskId}`);
+    }
+  }
+  const id = generateId("task");
+  const now = new Date;
+  const task = {
+    id,
+    projectId: project.id,
+    epicId: input.epicId ?? null,
+    parentTaskId: input.parentTaskId ?? null,
+    title: input.title,
+    description: input.description ?? null,
+    priority: input.priority ?? 2,
+    status: input.status ?? "todo",
+    tags: input.tags ?? null,
+    createdAt: now,
+    updatedAt: now
+  };
+  db.insert(tasks).values(task).run();
+  return task;
+}
+function getTask(id) {
+  const db = getDb();
+  const result = db.select().from(tasks).where(eq3(tasks.id, id)).get();
+  return result;
+}
+function listTasks(options) {
+  const db = getDb();
+  const conditions = [];
+  if (options?.status) {
+    conditions.push(eq3(tasks.status, options.status));
+  }
+  if (options?.epicId) {
+    conditions.push(eq3(tasks.epicId, options.epicId));
+  }
+  if (options?.parentTaskId === null) {
+    conditions.push(isNull(tasks.parentTaskId));
+  } else if (options?.parentTaskId) {
+    conditions.push(eq3(tasks.parentTaskId, options.parentTaskId));
+  }
+  if (conditions.length > 0) {
+    return db.select().from(tasks).where(and(...conditions)).all();
+  }
+  return db.select().from(tasks).all();
+}
+function listSubtasks(parentTaskId) {
+  const db = getDb();
+  return db.select().from(tasks).where(eq3(tasks.parentTaskId, parentTaskId)).all();
+}
+function updateTask(id, input) {
+  const db = getDb();
+  const existing = getTask(id);
+  if (!existing) {
+    throw new Error(`Task not found: ${id}`);
+  }
+  if (input.epicId) {
+    const epic = db.select().from(epics).where(eq3(epics.id, input.epicId)).get();
+    if (!epic) {
+      throw new Error(`Epic not found: ${input.epicId}`);
+    }
+  }
+  const updates = {
+    updatedAt: new Date
+  };
+  if (input.title !== undefined)
+    updates.title = input.title;
+  if (input.description !== undefined)
+    updates.description = input.description;
+  if (input.priority !== undefined)
+    updates.priority = input.priority;
+  if (input.status !== undefined)
+    updates.status = input.status;
+  if (input.tags !== undefined)
+    updates.tags = input.tags;
+  if (input.epicId !== undefined)
+    updates.epicId = input.epicId;
+  db.update(tasks).set(updates).where(eq3(tasks.id, id)).run();
+  return getTask(id);
+}
+function deleteTask(id) {
+  const db = getDb();
+  const existing = getTask(id);
+  if (!existing) {
+    throw new Error(`Task not found: ${id}`);
+  }
+  db.delete(tasks).where(eq3(tasks.id, id)).run();
+}
+
+// src/commands/task.ts
+var taskCommand = new Command4("task").description("Manage tasks");
+taskCommand.command("create").description("Create a new task").requiredOption("-t, --title <title>", "Task title").option("-d, --description <description>", "Task description").option("-p, --priority <priority>", "Priority (0-5, default: 2)").option("-s, --status <status>", "Status (todo, in_progress, completed, wont_fix, archived)").option("--tags <tags>", "Comma-separated tags").option("-e, --epic <epic-id>", "Epic ID to assign task to").action((options) => {
+  try {
+    validateRequired(options.title, "Title");
+    const task = createTask({
+      title: options.title,
+      description: options.description,
+      priority: parsePriority(options.priority),
+      status: parseStatus(options.status, "task"),
+      tags: options.tags,
+      epicId: options.epic
+    });
+    if (isJsonMode()) {
+      output(task);
+    } else {
+      success(`Task created: ${task.id}`);
+      console.log(formatTask(task));
+    }
+  } catch (err) {
+    error(err instanceof Error ? err.message : String(err));
+    process.exit(1);
+  }
+});
+taskCommand.command("list").description("List all tasks").option("-s, --status <status>", "Filter by status").option("-e, --epic <epic-id>", "Filter by epic").action((options) => {
+  try {
+    const status = parseStatus(options.status, "task");
+    const tasks2 = listTasks({
+      status,
+      epicId: options.epic,
+      parentTaskId: null
+    });
+    if (isJsonMode()) {
+      output(tasks2);
+    } else {
+      console.log(formatTaskList(tasks2));
+    }
+  } catch (err) {
+    error(err instanceof Error ? err.message : String(err));
+    process.exit(1);
+  }
+});
+taskCommand.command("show <task-id>").description("Show task details").action((taskId) => {
+  try {
+    const task = getTask(taskId);
+    if (!task) {
+      error(`Task not found: ${taskId}`);
+      process.exit(1);
+    }
+    if (isJsonMode()) {
+      output(task);
+    } else {
+      console.log(formatTask(task));
+    }
+  } catch (err) {
+    error(err instanceof Error ? err.message : String(err));
+    process.exit(1);
+  }
+});
+taskCommand.command("update <task-id>").description("Update a task").option("-t, --title <title>", "New title").option("-d, --description <description>", "New description").option("-p, --priority <priority>", "New priority (0-5)").option("-s, --status <status>", "New status").option("--tags <tags>", "New tags (comma-separated)").option("-e, --epic <epic-id>", "New epic ID").option("--no-epic", "Remove from epic").action((taskId, options) => {
+  try {
+    const updateInput = {};
+    if (options.title !== undefined)
+      updateInput.title = options.title;
+    if (options.description !== undefined)
+      updateInput.description = options.description;
+    if (options.priority !== undefined)
+      updateInput.priority = parsePriority(options.priority);
+    if (options.status !== undefined) {
+      updateInput.status = parseStatus(options.status, "task");
+    }
+    if (options.tags !== undefined)
+      updateInput.tags = options.tags;
+    if (options.epic === false) {
+      updateInput.epicId = null;
+    } else if (options.epic !== undefined) {
+      updateInput.epicId = options.epic;
+    }
+    const task = updateTask(taskId, updateInput);
+    if (isJsonMode()) {
+      output(task);
+    } else {
+      success(`Task updated: ${task.id}`);
+      console.log(formatTask(task));
+    }
+  } catch (err) {
+    error(err instanceof Error ? err.message : String(err));
+    process.exit(1);
+  }
+});
+taskCommand.command("delete <task-id>").description("Delete a task").action((taskId) => {
+  try {
+    deleteTask(taskId);
+    success(`Task deleted: ${taskId}`);
+  } catch (err) {
+    error(err instanceof Error ? err.message : String(err));
+    process.exit(1);
+  }
+});
+
+// src/commands/subtask.ts
+import { Command as Command5 } from "commander";
+var subtaskCommand = new Command5("subtask").description("Manage subtasks");
+subtaskCommand.command("create <parent-task-id>").description("Create a new subtask").requiredOption("-t, --title <title>", "Subtask title").option("-d, --description <description>", "Subtask description").option("-p, --priority <priority>", "Priority (0-5, default: 2)").option("-s, --status <status>", "Status (todo, in_progress, completed, wont_fix, archived)").action((parentTaskId, options) => {
+  try {
+    validateRequired(options.title, "Title");
+    const parent = getTask(parentTaskId);
+    if (!parent) {
+      error(`Parent task not found: ${parentTaskId}`);
+      process.exit(1);
+    }
+    const subtask = createTask({
+      title: options.title,
+      description: options.description,
+      priority: parsePriority(options.priority),
+      status: parseStatus(options.status, "task"),
+      parentTaskId,
+      epicId: parent.epicId ?? undefined
+    });
+    if (isJsonMode()) {
+      output(subtask);
+    } else {
+      success(`Subtask created: ${subtask.id}`);
+      console.log(formatTask(subtask));
+    }
+  } catch (err) {
+    error(err instanceof Error ? err.message : String(err));
+    process.exit(1);
+  }
+});
+subtaskCommand.command("list <parent-task-id>").description("List all subtasks of a task").action((parentTaskId) => {
+  try {
+    const parent = getTask(parentTaskId);
+    if (!parent) {
+      error(`Parent task not found: ${parentTaskId}`);
+      process.exit(1);
+    }
+    const subtasks = listSubtasks(parentTaskId);
+    if (isJsonMode()) {
+      output(subtasks);
+    } else {
+      if (subtasks.length === 0) {
+        console.log(`No subtasks for ${parentTaskId}`);
+      } else {
+        console.log(`Subtasks of ${parentTaskId}:`);
+        console.log(formatTaskList(subtasks));
+      }
+    }
+  } catch (err) {
+    error(err instanceof Error ? err.message : String(err));
+    process.exit(1);
+  }
+});
+subtaskCommand.command("update <subtask-id>").description("Update a subtask").option("-t, --title <title>", "New title").option("-d, --description <description>", "New description").option("-p, --priority <priority>", "New priority (0-5)").option("-s, --status <status>", "New status").action((subtaskId, options) => {
+  try {
+    const subtask = getTask(subtaskId);
+    if (!subtask) {
+      error(`Subtask not found: ${subtaskId}`);
+      process.exit(1);
+    }
+    if (!subtask.parentTaskId) {
+      error(`${subtaskId} is not a subtask. Use 'trekker task update' instead.`);
+      process.exit(1);
+    }
+    const updateInput = {};
+    if (options.title !== undefined)
+      updateInput.title = options.title;
+    if (options.description !== undefined)
+      updateInput.description = options.description;
+    if (options.priority !== undefined)
+      updateInput.priority = parsePriority(options.priority);
+    if (options.status !== undefined) {
+      updateInput.status = parseStatus(options.status, "task");
+    }
+    const updated = updateTask(subtaskId, updateInput);
+    if (isJsonMode()) {
+      output(updated);
+    } else {
+      success(`Subtask updated: ${updated.id}`);
+      console.log(formatTask(updated));
+    }
+  } catch (err) {
+    error(err instanceof Error ? err.message : String(err));
+    process.exit(1);
+  }
+});
+subtaskCommand.command("delete <subtask-id>").description("Delete a subtask").action((subtaskId) => {
+  try {
+    const subtask = getTask(subtaskId);
+    if (!subtask) {
+      error(`Subtask not found: ${subtaskId}`);
+      process.exit(1);
+    }
+    if (!subtask.parentTaskId) {
+      error(`${subtaskId} is not a subtask. Use 'trekker task delete' instead.`);
+      process.exit(1);
+    }
+    deleteTask(subtaskId);
+    success(`Subtask deleted: ${subtaskId}`);
+  } catch (err) {
+    error(err instanceof Error ? err.message : String(err));
+    process.exit(1);
+  }
+});
+
+// src/commands/comment.ts
+import { Command as Command6 } from "commander";
+
+// src/services/comment.ts
+import { eq as eq4 } from "drizzle-orm";
+function createComment(input) {
+  const db = getDb();
+  const task = db.select().from(tasks).where(eq4(tasks.id, input.taskId)).get();
+  if (!task) {
+    throw new Error(`Task not found: ${input.taskId}`);
+  }
+  const id = generateId("comment");
+  const now = new Date;
+  const comment = {
+    id,
+    taskId: input.taskId,
+    author: input.author,
+    content: input.content,
+    createdAt: now,
+    updatedAt: now
+  };
+  db.insert(comments).values(comment).run();
+  return comment;
+}
+function getComment(id) {
+  const db = getDb();
+  const result = db.select().from(comments).where(eq4(comments.id, id)).get();
+  return result;
+}
+function listComments(taskId) {
+  const db = getDb();
+  const task = db.select().from(tasks).where(eq4(tasks.id, taskId)).get();
+  if (!task) {
+    throw new Error(`Task not found: ${taskId}`);
+  }
+  return db.select().from(comments).where(eq4(comments.taskId, taskId)).all();
+}
+function updateComment(id, input) {
+  const db = getDb();
+  const existing = getComment(id);
+  if (!existing) {
+    throw new Error(`Comment not found: ${id}`);
+  }
+  db.update(comments).set({
+    content: input.content,
+    updatedAt: new Date
+  }).where(eq4(comments.id, id)).run();
+  return getComment(id);
+}
+function deleteComment(id) {
+  const db = getDb();
+  const existing = getComment(id);
+  if (!existing) {
+    throw new Error(`Comment not found: ${id}`);
+  }
+  db.delete(comments).where(eq4(comments.id, id)).run();
+}
+
+// src/commands/comment.ts
+var commentCommand = new Command6("comment").description("Manage comments");
+commentCommand.command("add <task-id>").description("Add a comment to a task").requiredOption("-a, --author <author>", "Comment author").requiredOption("-c, --content <content>", "Comment content").action((taskId, options) => {
+  try {
+    validateRequired(options.author, "Author");
+    validateRequired(options.content, "Content");
+    const comment = createComment({
+      taskId,
+      author: options.author,
+      content: options.content
+    });
+    if (isJsonMode()) {
+      output(comment);
+    } else {
+      success(`Comment added: ${comment.id}`);
+      console.log(formatComment(comment));
+    }
+  } catch (err) {
+    error(err instanceof Error ? err.message : String(err));
+    process.exit(1);
+  }
+});
+commentCommand.command("list <task-id>").description("List all comments on a task").action((taskId) => {
+  try {
+    const comments2 = listComments(taskId);
+    if (isJsonMode()) {
+      output(comments2);
+    } else {
+      if (comments2.length === 0) {
+        console.log(`No comments on ${taskId}`);
+      } else {
+        console.log(`Comments on ${taskId}:`);
+        console.log(formatCommentList(comments2));
+      }
+    }
+  } catch (err) {
+    error(err instanceof Error ? err.message : String(err));
+    process.exit(1);
+  }
+});
+commentCommand.command("update <comment-id>").description("Update a comment").requiredOption("-c, --content <content>", "New comment content").action((commentId, options) => {
+  try {
+    validateRequired(options.content, "Content");
+    const comment = updateComment(commentId, {
+      content: options.content
+    });
+    if (isJsonMode()) {
+      output(comment);
+    } else {
+      success(`Comment updated: ${comment.id}`);
+      console.log(formatComment(comment));
+    }
+  } catch (err) {
+    error(err instanceof Error ? err.message : String(err));
+    process.exit(1);
+  }
+});
+commentCommand.command("delete <comment-id>").description("Delete a comment").action((commentId) => {
+  try {
+    deleteComment(commentId);
+    success(`Comment deleted: ${commentId}`);
+  } catch (err) {
+    error(err instanceof Error ? err.message : String(err));
+    process.exit(1);
+  }
+});
+
+// src/commands/dep.ts
+import { Command as Command7 } from "commander";
+
+// src/services/dependency.ts
+import { eq as eq5 } from "drizzle-orm";
+function addDependency(taskId, dependsOnId) {
+  const db = getDb();
+  const task = db.select().from(tasks).where(eq5(tasks.id, taskId)).get();
+  if (!task) {
+    throw new Error(`Task not found: ${taskId}`);
+  }
+  const dependsOnTask = db.select().from(tasks).where(eq5(tasks.id, dependsOnId)).get();
+  if (!dependsOnTask) {
+    throw new Error(`Task not found: ${dependsOnId}`);
+  }
+  if (taskId === dependsOnId) {
+    throw new Error("A task cannot depend on itself.");
+  }
+  const existing = db.select().from(dependencies).where(eq5(dependencies.taskId, taskId)).all().find((d) => d.dependsOnId === dependsOnId);
+  if (existing) {
+    throw new Error(`Dependency already exists: ${taskId} \u2192 ${dependsOnId}`);
+  }
+  if (wouldCreateCycle(taskId, dependsOnId)) {
+    throw new Error(`Adding this dependency would create a cycle. ${dependsOnId} already depends on ${taskId} (directly or transitively).`);
+  }
+  const id = generateUuid();
+  const now = new Date;
+  const dependency = {
+    id,
+    taskId,
+    dependsOnId,
+    createdAt: now
+  };
+  db.insert(dependencies).values(dependency).run();
+  return dependency;
+}
+function removeDependency(taskId, dependsOnId) {
+  const db = getDb();
+  const existing = db.select().from(dependencies).where(eq5(dependencies.taskId, taskId)).all().find((d) => d.dependsOnId === dependsOnId);
+  if (!existing) {
+    throw new Error(`Dependency not found: ${taskId} \u2192 ${dependsOnId}`);
+  }
+  db.delete(dependencies).where(eq5(dependencies.id, existing.id)).run();
+}
+function getDependencies(taskId) {
+  const db = getDb();
+  const dependsOn = db.select({
+    taskId: dependencies.taskId,
+    dependsOnId: dependencies.dependsOnId
+  }).from(dependencies).where(eq5(dependencies.taskId, taskId)).all();
+  const blocks = db.select({
+    taskId: dependencies.taskId,
+    dependsOnId: dependencies.dependsOnId
+  }).from(dependencies).where(eq5(dependencies.dependsOnId, taskId)).all();
+  return { dependsOn, blocks };
+}
+function wouldCreateCycle(taskId, dependsOnId) {
+  const db = getDb();
+  const visited = new Set;
+  const stack = [dependsOnId];
+  while (stack.length > 0) {
+    const current = stack.pop();
+    if (current === taskId) {
+      return true;
+    }
+    if (visited.has(current)) {
+      continue;
+    }
+    visited.add(current);
+    const deps = db.select({ dependsOnId: dependencies.dependsOnId }).from(dependencies).where(eq5(dependencies.taskId, current)).all();
+    for (const dep of deps) {
+      if (!visited.has(dep.dependsOnId)) {
+        stack.push(dep.dependsOnId);
+      }
+    }
+  }
+  return false;
+}
+
+// src/commands/dep.ts
+var depCommand = new Command7("dep").description("Manage task dependencies");
+depCommand.command("add <task-id> <depends-on-id>").description("Add a dependency (task-id depends on depends-on-id)").action((taskId, dependsOnId) => {
+  try {
+    const dependency = addDependency(taskId, dependsOnId);
+    if (isJsonMode()) {
+      output(dependency);
+    } else {
+      success(`Dependency added: ${taskId} \u2192 depends on ${dependsOnId}`);
+    }
+  } catch (err) {
+    error(err instanceof Error ? err.message : String(err));
+    process.exit(1);
+  }
+});
+depCommand.command("remove <task-id> <depends-on-id>").description("Remove a dependency").action((taskId, dependsOnId) => {
+  try {
+    removeDependency(taskId, dependsOnId);
+    success(`Dependency removed: ${taskId} \u2192 ${dependsOnId}`);
+  } catch (err) {
+    error(err instanceof Error ? err.message : String(err));
+    process.exit(1);
+  }
+});
+depCommand.command("list <task-id>").description("List dependencies for a task").action((taskId) => {
+  try {
+    const { dependsOn, blocks } = getDependencies(taskId);
+    if (isJsonMode()) {
+      output({ taskId, dependsOn, blocks });
+    } else {
+      console.log(`Dependencies for ${taskId}:`);
+      console.log(`
+Depends on:`);
+      console.log(formatDependencyList(dependsOn, "depends_on"));
+      console.log(`
+Blocks:`);
+      console.log(formatDependencyList(blocks, "blocks"));
+    }
+  } catch (err) {
+    error(err instanceof Error ? err.message : String(err));
+    process.exit(1);
+  }
+});
+
+// src/commands/quickstart.ts
+import { Command as Command8 } from "commander";
+var QUICKSTART_TEXT = `# Trekker - AI Agent Quickstart Guide
+
+Trekker is a CLI-based issue tracker designed for coding agents. It stores all data in a local SQLite database at \`.trekker/trekker.db\` in your project root.
+
+## Why Use Trekker?
+
+As an AI agent, you should use Trekker to:
+- **Track your work** across multiple sessions and context windows
+- **Break down complex tasks** into manageable, atomic pieces
+- **Document decisions** and progress for future reference
+- **Manage dependencies** between tasks to ensure correct execution order
+- **Offload context** - store your reasoning, findings, and state externally so you can recover after context resets
+- **Persist memory** - comments survive context window limits and session boundaries
+
+## Best Practices for AI Agents
+
+### Creating Epics
+- Create one epic per **feature or major goal**
+- Use clear, descriptive titles that explain the outcome (e.g., "User Authentication System" not "Auth")
+- Write descriptions that capture the **why** and **scope** of the work
+- Example: \`trekker epic create -t "REST API for User Management" -d "Build CRUD endpoints for users with JWT auth, input validation, and rate limiting"\`
+
+### Creating Atomic Tasks
+- Each task should be **completable in one focused session**
+- Tasks should have a **single, clear objective**
+- If a task feels too big, break it into subtasks
+- Use action verbs: "Implement", "Add", "Fix", "Refactor", "Update"
+- Bad: \`"Work on authentication"\`
+- Good: \`"Implement JWT token generation endpoint"\`
+
+### Writing Good Descriptions
+- Explain **what** needs to be done and **how** to verify it's complete
+- Include relevant technical details (endpoints, file paths, function names)
+- Mention acceptance criteria when applicable
+- Example: \`-d "Create POST /api/auth/login that accepts {email, password}, validates credentials against DB, returns JWT token. Should return 401 for invalid credentials."\`
+
+### Using Tags Effectively
+- Use tags to categorize work: \`--tags "api,auth,security"\`
+- Common tag categories: component (\`api\`, \`ui\`, \`db\`), type (\`bug\`, \`feature\`, \`refactor\`), area (\`auth\`, \`payments\`)
+
+### Managing Dependencies
+- Always define dependencies when task order matters
+- A task should not start until its dependencies are complete
+- Use \`trekker dep list <task-id>\` to check what's blocking a task
+
+### Adding Comments (Critical for Context Management)
+
+Comments are your **external memory**. Use them extensively to:
+
+**Save Your Thought Process:**
+- Document your reasoning and analysis as you work
+- Record hypotheses before investigating them
+- Note alternatives you considered and why you chose/rejected them
+
+**Offload Context:**
+- When your context window is filling up, dump your current state into comments
+- Record what you've tried, what worked, what didn't
+- Save partial progress so you can resume after a context reset
+
+**Preserve Investigation Results:**
+- Store findings from code exploration
+- Document file locations and relevant code snippets
+- Record error messages and stack traces you're debugging
+
+**Track Decision History:**
+- Log architectural decisions with rationale
+- Document trade-offs you evaluated
+- Record blockers and how you resolved them
+
+**Examples:**
+\`\`\`bash
+# Starting a task - record your initial analysis
+trekker comment add TREK-1 -a "agent" -c "Initial analysis: Need to modify auth.ts (line 45-80) and add new endpoint in routes/api.ts. Dependencies: bcrypt, jsonwebtoken already installed."
+
+# During investigation - save what you found
+trekker comment add TREK-1 -a "agent" -c "Found existing validation in utils/validate.ts:23. Can reuse validateEmail() and validatePassword(). Token generation should follow pattern in auth/jwt.ts."
+
+# Recording a decision
+trekker comment add TREK-1 -a "agent" -c "Decision: Using bcrypt over argon2 for password hashing. Rationale: better library support, existing team familiarity, sufficient security for this use case."
+
+# Saving progress before context reset
+trekker comment add TREK-1 -a "agent" -c "Progress checkpoint: Implemented login endpoint (auth.ts:45-120). TODO: Add rate limiting, write tests. Blocked by: Need to clarify password reset flow with user."
+
+# After hitting an issue
+trekker comment add TREK-1 -a "agent" -c "Issue: JWT verification failing. Tried: 1) Checked secret key - correct, 2) Verified token format - valid, 3) Found issue - clock skew on server. Solution: Added 30s leeway to verification."
+\`\`\`
+
+---
+
+## Initialization
+
+Before using Trekker, initialize it in your project directory:
+
+\`\`\`bash
+trekker init              # Creates .trekker/ directory with database
+\`\`\`
+
+To remove all Trekker data:
+
+\`\`\`bash
+trekker wipe              # Prompts for confirmation
+trekker wipe -y           # Skip confirmation
+\`\`\`
+
+## Global Options
+
+| Option    | Description                                |
+|-----------|--------------------------------------------|
+| \`--json\`  | Output in JSON format (recommended for agents) |
+| \`--help\`  | Show help for any command                  |
+
+**Example:**
+\`\`\`bash
+trekker --json task list  # Returns tasks as JSON array
+\`\`\`
+
+---
+
+## Epics
+
+> High-level features or milestones
+
+### Create Epic
+
+\`\`\`bash
+trekker epic create -t <title> [-d <description>] [-p <0-5>] [-s <status>]
+\`\`\`
+
+| Option | Required | Description |
+|--------|----------|-------------|
+| \`-t, --title\` | Yes | Epic title |
+| \`-d, --description\` | No | Detailed description |
+| \`-p, --priority\` | No | 0=critical, 1=high, 2=medium (default), 3=low, 4=backlog, 5=someday |
+| \`-s, --status\` | No | todo (default), in_progress, completed, archived |
+
+**Example:**
+\`\`\`bash
+trekker epic create -t "User Authentication" -d "Implement OAuth2 login" -p 1
+\`\`\`
+
+### List Epics
+
+\`\`\`bash
+trekker epic list [--status <status>]
+\`\`\`
+
+### Show Epic
+
+\`\`\`bash
+trekker epic show <epic-id>
+\`\`\`
+
+### Update Epic
+
+\`\`\`bash
+trekker epic update <epic-id> [-t <title>] [-d <desc>] [-p <priority>] [-s <status>]
+\`\`\`
+
+### Delete Epic
+
+\`\`\`bash
+trekker epic delete <epic-id>
+\`\`\`
+
+---
+
+## Tasks
+
+> Work items that can be assigned to epics
+
+### Create Task
+
+\`\`\`bash
+trekker task create -t <title> [-d <description>] [-p <0-5>] [-s <status>] [--tags <tags>] [-e <epic-id>]
+\`\`\`
+
+| Option | Required | Description |
+|--------|----------|-------------|
+| \`-t, --title\` | Yes | Task title |
+| \`-d, --description\` | No | Detailed description |
+| \`-p, --priority\` | No | 0-5, default: 2 |
+| \`-s, --status\` | No | todo (default), in_progress, completed, wont_fix, archived |
+| \`--tags\` | No | Comma-separated tags, e.g., "api,auth,backend" |
+| \`-e, --epic\` | No | Epic ID to assign task to |
+
+**Example:**
+\`\`\`bash
+trekker task create -t "Implement login API" -d "POST /api/login endpoint" -e EPIC-1 --tags "api,auth"
+\`\`\`
+
+### List Tasks
+
+\`\`\`bash
+trekker task list [--status <status>] [--epic <epic-id>]
+\`\`\`
+
+**Examples:**
+\`\`\`bash
+trekker task list                      # All top-level tasks
+trekker task list --status todo        # Filter by status
+trekker task list --epic EPIC-1        # Filter by epic
+\`\`\`
+
+### Show Task
+
+\`\`\`bash
+trekker task show <task-id>
+trekker --json task show TREK-1        # Get full task details as JSON
+\`\`\`
+
+### Update Task
+
+\`\`\`bash
+trekker task update <task-id> [-t <title>] [-d <desc>] [-p <priority>] [-s <status>] [--tags <tags>] [-e <epic-id>] [--no-epic]
+\`\`\`
+
+**Examples:**
+\`\`\`bash
+trekker task update TREK-1 -s in_progress
+trekker task update TREK-1 --no-epic   # Remove from epic
+\`\`\`
+
+### Delete Task
+
+\`\`\`bash
+trekker task delete <task-id>
+\`\`\`
+
+---
+
+## Subtasks
+
+> Child tasks that belong to a parent task. They inherit the epic from their parent.
+
+### Create Subtask
+
+\`\`\`bash
+trekker subtask create <parent-task-id> -t <title> [-d <description>] [-p <0-5>] [-s <status>]
+\`\`\`
+
+**Example:**
+\`\`\`bash
+trekker subtask create TREK-1 -t "Add input validation"
+\`\`\`
+
+### List Subtasks
+
+\`\`\`bash
+trekker subtask list <parent-task-id>
+\`\`\`
+
+### Update Subtask
+
+\`\`\`bash
+trekker subtask update <subtask-id> [-t <title>] [-d <desc>] [-p <priority>] [-s <status>]
+\`\`\`
+
+### Delete Subtask
+
+\`\`\`bash
+trekker subtask delete <subtask-id>
+\`\`\`
+
+---
+
+## Comments
+
+> Your external memory - use extensively to preserve context and reasoning
+
+Comments are **critical for AI agents**. They persist beyond your context window and session boundaries. Use them to:
+- Store your analysis and reasoning
+- Save investigation results
+- Record decisions with rationale
+- Checkpoint progress before context resets
+- Document blockers and solutions
+
+### Add Comment
+
+\`\`\`bash
+trekker comment add <task-id> -a <author> -c <content>
+\`\`\`
+
+| Option | Required | Description |
+|--------|----------|-------------|
+| \`-a, --author\` | Yes | Comment author name (use "agent" for AI) |
+| \`-c, --content\` | Yes | Comment text (can be multi-line) |
+
+**Examples:**
+\`\`\`bash
+# Record analysis
+trekker comment add TREK-1 -a "agent" -c "Analyzed codebase: auth logic in src/auth/, uses JWT stored in httpOnly cookies"
+
+# Save progress checkpoint
+trekker comment add TREK-1 -a "agent" -c "Checkpoint: Completed steps 1-3. Next: implement validation. Files modified: auth.ts, routes.ts"
+
+# Document a blocker
+trekker comment add TREK-1 -a "agent" -c "BLOCKED: Need clarification on password requirements. Asked user, waiting for response."
+\`\`\`
+
+### List Comments
+
+\`\`\`bash
+trekker comment list <task-id>
+trekker --json comment list <task-id>    # Get as JSON for parsing
+\`\`\`
+
+**Pro tip:** Always read comments when resuming work on a task - they contain your previous context!
+
+### Update Comment
+
+\`\`\`bash
+trekker comment update <comment-id> -c <new-content>
+\`\`\`
+
+### Delete Comment
+
+\`\`\`bash
+trekker comment delete <comment-id>
+\`\`\`
+
+---
+
+## Dependencies
+
+> Task relationships - which tasks must be completed before others can start.
+> Trekker automatically detects and prevents circular dependencies.
+
+### Add Dependency
+
+\`\`\`bash
+trekker dep add <task-id> <depends-on-id>
+\`\`\`
+
+This means:
+- \`<task-id>\` depends on \`<depends-on-id>\`
+- \`<task-id>\` cannot start until \`<depends-on-id>\` is done
+
+**Example:**
+\`\`\`bash
+trekker dep add TREK-2 TREK-1    # TREK-2 depends on TREK-1
+\`\`\`
+
+### Remove Dependency
+
+\`\`\`bash
+trekker dep remove <task-id> <depends-on-id>
+\`\`\`
+
+### List Dependencies
+
+\`\`\`bash
+trekker dep list <task-id>
+\`\`\`
+
+Shows both:
+- What this task depends on (blockers)
+- What tasks this task blocks
+
+---
+
+## Web Interface
+
+Trekker includes a web interface for visual task management.
+
+### Start the Web Interface
+
+\`\`\`bash
+trekker serve              # Start on port 3000
+trekker serve -p 8080      # Start on custom port
+\`\`\`
+
+The web interface provides:
+- Kanban board with tasks grouped by status (TODO, In Progress, Completed)
+- Epic filter to focus on specific features
+- Task details including dependencies, subtasks, and tags
+- Auto-refresh every 5 seconds to reflect CLI changes
+
+---
+
+## Reference
+
+### ID Formats
+
+| Type | Format | Example |
+|------|--------|---------|
+| Epic | \`EPIC-n\` | EPIC-1, EPIC-2 |
+| Task/Subtask | \`TREK-n\` | TREK-1, TREK-42 |
+| Comment | \`CMT-n\` | CMT-1, CMT-5 |
+
+IDs are auto-generated and sequential within each type.
+
+### Task Status Values
+
+| Status | Description |
+|--------|-------------|
+| \`todo\` | Not started (default) |
+| \`in_progress\` | Currently being worked on |
+| \`completed\` | Finished successfully |
+| \`wont_fix\` | Decided not to implement |
+| \`archived\` | No longer relevant |
+
+### Epic Status Values
+
+| Status | Description |
+|--------|-------------|
+| \`todo\` | Not started (default) |
+| \`in_progress\` | Work has begun |
+| \`completed\` | All tasks done |
+| \`archived\` | No longer relevant |
+
+### Priority Scale
+
+| Value | Meaning |
+|-------|---------|
+| 0 | Critical (drop everything) |
+| 1 | High (do soon) |
+| 2 | Medium (default) |
+| 3 | Low (when time permits) |
+| 4 | Backlog (future consideration) |
+| 5 | Someday (nice to have) |
+
+---
+
+## Recommended Workflow for AI Agents
+
+1. **Initialize** (once per project):
+   \`\`\`bash
+   trekker init
+   \`\`\`
+
+2. **Check existing state** (every session start):
+   \`\`\`bash
+   trekker --json task list --status in_progress   # See what's active
+   trekker --json comment list TREK-1              # Read your previous context
+   \`\`\`
+
+3. **Create epic** for the feature you're working on:
+   \`\`\`bash
+   trekker epic create -t "Feature Name" -d "Description"
+   \`\`\`
+
+4. **Create tasks** for each piece of work:
+   \`\`\`bash
+   trekker task create -t "Task name" -e EPIC-1
+   \`\`\`
+
+5. **Add dependencies** if tasks have ordering requirements:
+   \`\`\`bash
+   trekker dep add TREK-2 TREK-1
+   \`\`\`
+
+6. **Document your initial analysis** before starting work:
+   \`\`\`bash
+   trekker comment add TREK-1 -a "agent" -c "Analysis: Need to modify X, Y, Z. Approach: ..."
+   \`\`\`
+
+7. **Update status** as you work:
+   \`\`\`bash
+   trekker task update TREK-1 -s in_progress
+   \`\`\`
+
+8. **Add comments frequently** - this is your external memory:
+   \`\`\`bash
+   # After investigating
+   trekker comment add TREK-1 -a "agent" -c "Found: auth logic in src/auth.ts:45-80"
+
+   # After making a decision
+   trekker comment add TREK-1 -a "agent" -c "Decision: Using approach X because Y"
+
+   # Before context might reset
+   trekker comment add TREK-1 -a "agent" -c "Checkpoint: Completed A, B. Next: C, D"
+   \`\`\`
+
+9. **Mark complete** when done:
+   \`\`\`bash
+   trekker task update TREK-1 -s completed
+   trekker comment add TREK-1 -a "agent" -c "Completed. Summary: Implemented X in files A, B, C."
+   \`\`\`
+
+10. **Use JSON output** for parsing:
+    \`\`\`bash
+    trekker --json task list
+    trekker --json task show TREK-1
+    \`\`\`
+
+---
+
+## Context Management Strategies
+
+AI agents have limited context windows. Use Trekker to extend your effective memory:
+
+### Starting a New Session
+
+Always begin by reading your previous state:
+\`\`\`bash
+# What was I working on?
+trekker --json task list --status in_progress
+
+# What did I learn/decide?
+trekker --json comment list TREK-1
+\`\`\`
+
+### During Long Tasks
+
+Periodically checkpoint your progress:
+\`\`\`bash
+trekker comment add TREK-1 -a "agent" -c "Progress: Steps 1-3 done. Current state: X. Next: Y. Blockers: Z."
+\`\`\`
+
+### Before Context Window Fills Up
+
+When you notice context getting large, dump your current mental state:
+\`\`\`bash
+trekker comment add TREK-1 -a "agent" -c "Context dump:
+- Working on: implementing login validation
+- Files involved: auth.ts (modified lines 45-80), routes.ts (new endpoint at line 120)
+- Current approach: using existing validateEmail() from utils
+- Remaining work: add rate limiting, write tests
+- Open questions: unclear if we need refresh tokens"
+\`\`\`
+
+### After Solving a Problem
+
+Document the solution so future-you doesn't repeat the investigation:
+\`\`\`bash
+trekker comment add TREK-1 -a "agent" -c "Solved: JWT verification failing. Root cause: clock skew. Fix: added 30s leeway in verify(). See auth.ts:67."
+\`\`\`
+
+### When Blocked
+
+Record what you're waiting for:
+\`\`\`bash
+trekker comment add TREK-1 -a "agent" -c "BLOCKED: Need user input on password complexity requirements. Asked in conversation. Current assumption: min 8 chars, 1 number."
+\`\`\`
+
+---
+
+## Common Scenarios
+
+### Start a new feature
+
+\`\`\`bash
+trekker epic create -t "API Rate Limiting" -d "Implement rate limiting for all endpoints" -p 1
+trekker task create -t "Design rate limit algorithm" -e EPIC-1
+trekker task create -t "Implement Redis counter" -e EPIC-1
+trekker task create -t "Add middleware" -e EPIC-1
+trekker dep add TREK-3 TREK-2    # Middleware depends on Redis counter
+trekker dep add TREK-2 TREK-1    # Redis counter depends on design
+\`\`\`
+
+### Check what's ready to work on
+
+\`\`\`bash
+trekker --json task list --status todo
+\`\`\`
+
+### Get all details about a task
+
+\`\`\`bash
+trekker --json task show TREK-1
+\`\`\`
+
+### Log progress
+
+\`\`\`bash
+trekker task update TREK-1 -s in_progress
+trekker comment add TREK-1 -a "agent" -c "Chose token bucket algorithm"
+trekker task update TREK-1 -s completed
+\`\`\`
+
+### Break down a complex task
+
+\`\`\`bash
+trekker subtask create TREK-2 -t "Set up Redis connection"
+trekker subtask create TREK-2 -t "Implement increment logic"
+trekker subtask create TREK-2 -t "Add TTL handling"
+\`\`\`
+
+### Resume work after context reset
+
+\`\`\`bash
+# 1. Find what you were working on
+trekker --json task list --status in_progress
+
+# 2. Read your previous comments to restore context
+trekker --json comment list TREK-1
+
+# 3. Read task details for full picture
+trekker --json task show TREK-1
+
+# 4. Continue work with restored context
+\`\`\`
+
+### Save context before stopping
+
+\`\`\`bash
+# Dump everything you know before session ends
+trekker comment add TREK-1 -a "agent" -c "Session end checkpoint:
+- Completed: login endpoint, validation
+- In progress: rate limiting (50% done, see middleware.ts:30)
+- Files modified: auth.ts, routes.ts, middleware.ts
+- Next steps: finish rate limiter, add tests
+- Notes: user prefers 100 req/min limit"
+\`\`\`
+`;
+var quickstartCommand = new Command8("quickstart").description("Show comprehensive guide for AI agents").action(() => {
+  console.log(QUICKSTART_TEXT);
+});
+
+// src/commands/serve.ts
+import { Command as Command9 } from "commander";
+import { spawn, spawnSync } from "child_process";
+import { resolve, dirname } from "path";
+import { existsSync as existsSync2 } from "fs";
+function findWebappDir() {
+  const scriptPath = import.meta.url.replace("file://", "");
+  const scriptDir = dirname(scriptPath);
+  const cliRoot = scriptDir.includes("/src/") ? dirname(dirname(dirname(scriptPath))) : dirname(dirname(scriptPath));
+  const bundledWebapp = resolve(cliRoot, "webapp-dist");
+  if (existsSync2(bundledWebapp)) {
+    return { path: bundledWebapp, isBundled: true };
+  }
+  const packagesDir = dirname(cliRoot);
+  const webappDir = resolve(packagesDir, "webapp");
+  if (existsSync2(webappDir)) {
+    return { path: webappDir, isBundled: false };
+  }
+  return null;
+}
+var serveCommand = new Command9("serve").description("Start the Trekker web interface").option("-p, --port <port>", "Port to run on", "3000").option("--dev", "Run in development mode").action(async (options) => {
+  try {
+    if (!isTrekkerInitialized()) {
+      error("Trekker is not initialized. Run 'trekker init' first.");
+      process.exit(1);
+    }
+    const dbPath = getDbPath();
+    const port = options.port;
+    const webapp = findWebappDir();
+    if (!webapp) {
+      error("Webapp not found. Please reinstall Trekker.");
+      process.exit(1);
+    }
+    const { path: webappDir, isBundled } = webapp;
+    const env = {
+      ...process.env,
+      TREKKER_DB_PATH: dbPath,
+      PORT: port
+    };
+    if (isBundled) {
+      success(`Starting Trekker web interface on http://localhost:${port}`);
+      console.log(`Press Ctrl+C to stop
+`);
+      const server2 = spawn("bun", ["run", "server.js"], {
+        cwd: webappDir,
+        stdio: "inherit",
+        env
+      });
+      setupSignalHandlers(server2);
+      return;
+    }
+    const nodeModulesPath = resolve(webappDir, "node_modules");
+    if (!existsSync2(nodeModulesPath)) {
+      console.log("Installing webapp dependencies...");
+      const result = spawnSync("bun", ["install"], {
+        cwd: webappDir,
+        stdio: "inherit"
+      });
+      if (result.status !== 0) {
+        error("Failed to install dependencies");
+        process.exit(1);
+      }
+    }
+    if (options.dev) {
+      success(`Starting Trekker web interface (dev) on http://localhost:${port}`);
+      console.log(`Press Ctrl+C to stop
+`);
+      const dev = spawn("bun", ["run", "dev", "--", "-p", port], {
+        cwd: webappDir,
+        stdio: "inherit",
+        env
+      });
+      setupSignalHandlers(dev);
+      return;
+    }
+    const standalonePath = resolve(webappDir, ".next", "standalone");
+    const buildMarker = resolve(webappDir, ".next", "BUILD_ID");
+    if (!existsSync2(standalonePath) || !existsSync2(buildMarker)) {
+      console.log("Building webapp...");
+      const result = spawnSync("bun", ["run", "build"], {
+        cwd: webappDir,
+        stdio: "inherit",
+        env
+      });
+      if (result.status !== 0) {
+        error("Failed to build webapp");
+        process.exit(1);
+      }
+    }
+    const staticSrc = resolve(webappDir, ".next", "static");
+    const staticDest = resolve(standalonePath, ".next", "static");
+    if (existsSync2(staticSrc) && !existsSync2(staticDest)) {
+      spawnSync("cp", ["-r", staticSrc, resolve(standalonePath, ".next")], {
+        stdio: "inherit"
+      });
+    }
+    const publicSrc = resolve(webappDir, "public");
+    const publicDest = resolve(standalonePath, "public");
+    if (existsSync2(publicSrc) && !existsSync2(publicDest)) {
+      spawnSync("cp", ["-r", publicSrc, standalonePath], {
+        stdio: "inherit"
+      });
+    }
+    success(`Starting Trekker web interface on http://localhost:${port}`);
+    console.log(`Press Ctrl+C to stop
+`);
+    const server = spawn("bun", ["run", "server.js"], {
+      cwd: standalonePath,
+      stdio: "inherit",
+      env
+    });
+    setupSignalHandlers(server);
+  } catch (err) {
+    error(err instanceof Error ? err.message : String(err));
+    process.exit(1);
+  }
+});
+function setupSignalHandlers(child) {
+  child.on("error", (err) => {
+    error(`Failed to start webapp: ${err.message}`);
+    process.exit(1);
+  });
+  process.on("SIGINT", () => {
+    child.kill("SIGINT");
+    process.exit(0);
+  });
+  process.on("SIGTERM", () => {
+    child.kill("SIGTERM");
+    process.exit(0);
+  });
+}
+
+// src/commands/seed.ts
+import { Command as Command10 } from "commander";
+var SAMPLE_EPICS = [
+  {
+    title: "User Authentication",
+    description: "Implement user authentication and authorization system",
+    priority: 0,
+    status: "in_progress"
+  },
+  {
+    title: "Dashboard",
+    description: "Build the main dashboard with analytics and metrics",
+    priority: 1,
+    status: "todo"
+  },
+  {
+    title: "API Development",
+    description: "Design and implement RESTful API endpoints",
+    priority: 1,
+    status: "in_progress"
+  },
+  {
+    title: "Testing & QA",
+    description: "Set up testing infrastructure and write tests",
+    priority: 2,
+    status: "todo"
+  }
+];
+var SAMPLE_TASKS = [
+  {
+    epicIndex: 0,
+    title: "Set up OAuth 2.0 provider",
+    description: "Configure OAuth 2.0 with Google and GitHub providers",
+    priority: 0,
+    status: "completed",
+    tags: "backend,security"
+  },
+  {
+    epicIndex: 0,
+    title: "Implement JWT token handling",
+    description: "Create JWT generation, validation, and refresh logic",
+    priority: 1,
+    status: "in_progress",
+    tags: "backend,security"
+  },
+  {
+    epicIndex: 0,
+    title: "Build login page",
+    description: "Create responsive login page with social login buttons",
+    priority: 1,
+    status: "todo",
+    tags: "frontend,ui"
+  },
+  {
+    epicIndex: 0,
+    title: "Add password reset flow",
+    description: "Implement forgot password and reset password functionality",
+    priority: 2,
+    status: "todo",
+    tags: "backend,frontend"
+  },
+  {
+    epicIndex: 1,
+    title: "Design dashboard layout",
+    description: "Create wireframes and mockups for the main dashboard",
+    priority: 1,
+    status: "completed",
+    tags: "design,ui"
+  },
+  {
+    epicIndex: 1,
+    title: "Implement chart components",
+    description: "Build reusable chart components using Chart.js",
+    priority: 2,
+    status: "in_progress",
+    tags: "frontend,ui"
+  },
+  {
+    epicIndex: 1,
+    title: "Add real-time data updates",
+    description: "Implement WebSocket connection for live dashboard updates",
+    priority: 2,
+    status: "todo",
+    tags: "frontend,backend"
+  },
+  {
+    epicIndex: 2,
+    title: "Define API schema",
+    description: "Document API endpoints using OpenAPI specification",
+    priority: 1,
+    status: "completed",
+    tags: "backend,docs"
+  },
+  {
+    epicIndex: 2,
+    title: "Implement user endpoints",
+    description: "Create CRUD endpoints for user management",
+    priority: 1,
+    status: "completed",
+    tags: "backend"
+  },
+  {
+    epicIndex: 2,
+    title: "Add rate limiting",
+    description: "Implement rate limiting middleware for API protection",
+    priority: 2,
+    status: "in_progress",
+    tags: "backend,security"
+  },
+  {
+    epicIndex: 2,
+    title: "Set up API versioning",
+    description: "Implement v1/v2 API versioning strategy",
+    priority: 3,
+    status: "todo",
+    tags: "backend"
+  },
+  {
+    epicIndex: 3,
+    title: "Set up Jest testing framework",
+    description: "Configure Jest with TypeScript support",
+    priority: 1,
+    status: "completed",
+    tags: "testing,devops"
+  },
+  {
+    epicIndex: 3,
+    title: "Write unit tests for auth module",
+    description: "Create comprehensive unit tests for authentication logic",
+    priority: 2,
+    status: "todo",
+    tags: "testing"
+  },
+  {
+    epicIndex: 3,
+    title: "Set up E2E testing with Playwright",
+    description: "Configure Playwright for end-to-end testing",
+    priority: 3,
+    status: "todo",
+    tags: "testing,devops"
+  },
+  {
+    epicIndex: null,
+    title: "Update README documentation",
+    description: "Add installation instructions and usage examples",
+    priority: 3,
+    status: "todo",
+    tags: "docs"
+  },
+  {
+    epicIndex: null,
+    title: "Configure CI/CD pipeline",
+    description: "Set up GitHub Actions for automated testing and deployment",
+    priority: 2,
+    status: "in_progress",
+    tags: "devops"
+  }
+];
+var SAMPLE_SUBTASKS = [
+  {
+    parentIndex: 1,
+    title: "Implement access token generation",
+    status: "completed",
+    priority: 1
+  },
+  {
+    parentIndex: 1,
+    title: "Implement refresh token logic",
+    status: "in_progress",
+    priority: 1
+  },
+  {
+    parentIndex: 1,
+    title: "Add token blacklisting",
+    status: "todo",
+    priority: 2
+  },
+  {
+    parentIndex: 5,
+    title: "Create bar chart component",
+    status: "completed",
+    priority: 2
+  },
+  {
+    parentIndex: 5,
+    title: "Create line chart component",
+    status: "in_progress",
+    priority: 2
+  },
+  {
+    parentIndex: 5,
+    title: "Create pie chart component",
+    status: "todo",
+    priority: 3
+  }
+];
+var SAMPLE_DEPENDENCIES = [
+  [2, 1],
+  [3, 1],
+  [6, 5],
+  [6, 4],
+  [9, 8],
+  [12, 11],
+  [13, 11]
+];
+var seedCommand = new Command10("seed").description("Seed the database with sample data (development only)").option("--force", "Skip confirmation prompt").action((options) => {
+  try {
+    if (!isTrekkerInitialized()) {
+      error("Trekker is not initialized. Run 'trekker init' first.");
+      process.exit(1);
+    }
+    if (!options.force) {
+      info("This will create sample epics, tasks, and dependencies.");
+      info(`Use --force to skip this confirmation.
+`);
+    }
+    const epicIds = [];
+    const taskIds = [];
+    info("Creating epics...");
+    for (const epicData of SAMPLE_EPICS) {
+      const epic = createEpic({
+        title: epicData.title,
+        description: epicData.description,
+        priority: epicData.priority,
+        status: epicData.status
+      });
+      epicIds.push(epic.id);
+      info(`  Created ${epic.id}: ${epic.title}`);
+    }
+    info(`
+Creating tasks...`);
+    for (const taskData of SAMPLE_TASKS) {
+      const task = createTask({
+        title: taskData.title,
+        description: taskData.description,
+        priority: taskData.priority,
+        status: taskData.status,
+        tags: taskData.tags,
+        epicId: taskData.epicIndex !== null ? epicIds[taskData.epicIndex] : undefined
+      });
+      taskIds.push(task.id);
+      info(`  Created ${task.id}: ${task.title}`);
+    }
+    info(`
+Creating subtasks...`);
+    for (const subtaskData of SAMPLE_SUBTASKS) {
+      const subtask = createTask({
+        title: subtaskData.title,
+        priority: subtaskData.priority,
+        status: subtaskData.status,
+        parentTaskId: taskIds[subtaskData.parentIndex]
+      });
+      info(`  Created ${subtask.id}: ${subtask.title} (subtask of ${taskIds[subtaskData.parentIndex]})`);
+    }
+    info(`
+Creating dependencies...`);
+    for (const [taskIndex, dependsOnIndex] of SAMPLE_DEPENDENCIES) {
+      const taskId = taskIds[taskIndex];
+      const dependsOnId = taskIds[dependsOnIndex];
+      addDependency(taskId, dependsOnId);
+      info(`  ${taskId} depends on ${dependsOnId}`);
+    }
+    success(`
+Seed complete! Created ${epicIds.length} epics, ${taskIds.length} tasks, ${SAMPLE_SUBTASKS.length} subtasks, and ${SAMPLE_DEPENDENCIES.length} dependencies.`);
+  } catch (err) {
+    error(err instanceof Error ? err.message : String(err));
+    process.exit(1);
+  }
+});
+
+// src/index.ts
+var program = new Command11;
+program.name("trekker").description("CLI-based issue tracker for coding agents").version("0.1.0").option("--json", "Output in JSON format").hook("preAction", (thisCommand) => {
+  const opts = thisCommand.opts();
+  if (opts.json) {
+    setJsonMode(true);
+  }
+});
+program.addCommand(initCommand);
+program.addCommand(wipeCommand);
+program.addCommand(epicCommand);
+program.addCommand(taskCommand);
+program.addCommand(subtaskCommand);
+program.addCommand(commentCommand);
+program.addCommand(depCommand);
+program.addCommand(quickstartCommand);
+program.addCommand(serveCommand);
+program.addCommand(seedCommand);
+program.parse();