@nickmeriano/task 0.7.0 → 0.8.0

package/src/store.ts

@@ -1,10 +1,11 @@
-import { DatabaseSync } from "node:sqlite"
 import { existsSync, readdirSync, readFileSync } from "node:fs"
 import { dirname, join, relative, sep } from "node:path"
 import type {
   Comment,
+  Goal,
+  GoalInput,
+  GoalPatch,
   ProjectConfig,
-  Status,
   Task,
   TaskFilter,
   TaskInput,
@@ -12,17 +13,16 @@ import type {
 } from "./types.ts"
 
 export const TASK_DIR = ".task"
-export const DB_FILE = "tasks.db"
 export const CONFIG_FILE = "config.json"
 
 /** Spacing between adjacent board positions — leaves room to drop between. */
 export const POSITION_GAP = 1024
 
 /**
- * What a board's persistence layer looks like, whichever representation backs
- * it. Two implementations: `FileStore` (text files in `.task/tickets/`, the
- * canonical format) and the legacy `TaskStore` (a committed SQLite database),
- * which survives so un-migrated boards keep working. `openBoard` picks.
+ * What a board's persistence layer looks like. One implementation: `FileStore`
+ * (text files in `.task/tickets/`, the canonical format). The interface stays
+ * because it is the seam everything else — the CLI, `task serve`, scripts —
+ * programs against.
  */
 export interface Store {
   readonly root: string
@@ -41,6 +41,17 @@ export interface Store {
   /** Move a done/canceled ticket to `.task/archive/`, out of the board's hot path. */
   archive(number: number): Task
   unarchive(number: number): Task
+  /** Live goals, in slug order — pass `true` to list `.task/goals/archive/` instead. */
+  goals(archived?: boolean): Goal[]
+  /** Live or archived — a ticket's `goal:` ref should resolve either way. */
+  getGoal(slug: string): Goal | null
+  createGoal(input: GoalInput): Goal
+  updateGoal(slug: string, patch: GoalPatch): Goal
+  /** Refused while any open (backlog/todo/in_progress) task references the goal. */
+  archiveGoal(slug: string): Goal
+  unarchiveGoal(slug: string): Goal
+  /** Refused while any live task references the goal, whatever its status. */
+  deleteGoal(slug: string): void
   comments(number: number): Comment[]
   addComment(number: number, body: string, author?: string): Comment
   deleteComment(number: number, commentId: string): Comment
@@ -153,427 +164,3 @@ export function derivePrefix(name: string): string {
   const word = name.toUpperCase().replace(/[^A-Z0-9]+/g, " ").trim().split(" ")[0]
   return (word || "TAS").slice(0, 3)
 }
-
-interface TaskRow {
-  id: number
-  title: string
-  description: string
-  status: string
-  tags: string
-  milestone: string | null
-  needs_human: number
-  prs: string
-  position: number
-  created_at: string
-  updated_at: string
-}
-
-interface CommentRow {
-  id: number
-  task_id: number
-  author: string
-  body: string
-  created_at: string
-}
-
-function now(): string {
-  return new Date().toISOString()
-}
-
-/**
- * The legacy persistence layer: one SQLite database inside `.task/`, opened
- * synchronously via node:sqlite (built into Node ≥22.13 — zero dependencies,
- * nothing to compile, safe for `npx`). Boards created before the text format
- * still run on this until `task migrate` moves them over.
- */
-export class TaskStore implements Store {
-  readonly root: string
-  readonly taskDir: string
-  readonly config: ProjectConfig
-  private db: DatabaseSync
-
-  constructor(root: string) {
-    this.root = root
-    this.taskDir = join(root, TASK_DIR)
-    this.config = JSON.parse(
-      readFileSync(join(this.taskDir, CONFIG_FILE), "utf8"),
-    ) as ProjectConfig
-    this.db = new DatabaseSync(join(this.taskDir, DB_FILE))
-    // Multiple writers (CLI + serve + agents) are expected; wait for locks
-    // instead of failing fast with SQLITE_BUSY.
-    this.db.exec("PRAGMA busy_timeout = 3000")
-    this.db.exec("PRAGMA foreign_keys = ON")
-    migrate(this.db)
-  }
-
-  close(): void {
-    this.db.close()
-  }
-
-  displayId(number: number): string {
-    return `${this.config.prefix}-${number}`
-  }
-
-  /** Accepts "PHONE-12", "phone-12" or "12". */
-  parseId(ref: string): number {
-    const match = /^(?:[A-Za-z0-9]+-)?(\d+)$/.exec(ref.trim())
-    if (!match) throw new Error(`invalid task id: ${ref}`)
-    return Number(match[1])
-  }
-
-  private toTask(row: TaskRow): Task {
-    return {
-      id: this.displayId(row.id),
-      number: row.id,
-      title: row.title,
-      description: row.description,
-      status: row.status as Status,
-      tags: JSON.parse(row.tags) as string[],
-      milestone: row.milestone,
-      needsHuman: row.needs_human !== 0,
-      blocks: this.linkedNumbers("blocker_id", row.id),
-      blockedBy: this.linkedNumbers("blocked_id", row.id),
-      prs: JSON.parse(row.prs) as string[],
-      position: row.position,
-      createdAt: row.created_at,
-      updatedAt: row.updated_at,
-    }
-  }
-
-  /** The other end of every link where `column` is this task. */
-  private linkedNumbers(column: "blocker_id" | "blocked_id", number: number): number[] {
-    const other = column === "blocker_id" ? "blocked_id" : "blocker_id"
-    const rows = this.db
-      .prepare(`SELECT ${other} AS n FROM task_links WHERE ${column} = ? ORDER BY ${other}`)
-      .all(number) as unknown as { n: number }[]
-    return rows.map((r) => r.n)
-  }
-
-  private toComment(row: CommentRow): Comment {
-    return {
-      id: String(row.id),
-      taskId: this.displayId(row.task_id),
-      author: row.author,
-      body: row.body,
-      createdAt: row.created_at,
-    }
-  }
-
-  list(filter: TaskFilter = {}): Task[] {
-    if (filter.archived) {
-      throw new Error("archiving needs a text-format board — run `task migrate` first")
-    }
-    const where: string[] = []
-    const params: (string | number)[] = []
-    if (filter.statuses?.length) {
-      where.push(`status IN (${filter.statuses.map(() => "?").join(", ")})`)
-      params.push(...filter.statuses)
-    }
-    if (filter.milestone) {
-      where.push("milestone = ?")
-      params.push(filter.milestone)
-    }
-    if (filter.needsHuman !== undefined) {
-      where.push("needs_human = ?")
-      params.push(filter.needsHuman ? 1 : 0)
-    }
-    const sql = `SELECT * FROM tasks${where.length ? ` WHERE ${where.join(" AND ")}` : ""} ORDER BY position, id`
-    let rows = this.db.prepare(sql).all(...params) as unknown as TaskRow[]
-    if (filter.tags?.length) {
-      // Tags are a JSON blob, not a table — match them in JS, any-of.
-      const wanted = new Set(filter.tags)
-      rows = rows.filter((r) => (JSON.parse(r.tags) as string[]).some((t) => wanted.has(t)))
-    }
-    return rows.map((r) => this.toTask(r))
-  }
-
-  get(number: number): Task | null {
-    const row = this.db.prepare("SELECT * FROM tasks WHERE id = ?").get(number) as
-      | TaskRow
-      | undefined
-    return row ? this.toTask(row) : null
-  }
-
-  create(input: TaskInput): Task {
-    const status = input.status ?? "todo"
-    // New tasks land at the bottom of their column.
-    const max = this.db
-      .prepare("SELECT MAX(position) AS max FROM tasks WHERE status = ?")
-      .get(status) as { max: number | null }
-    const timestamp = now()
-    const result = this.db
-      .prepare(
-        `INSERT INTO tasks (title, description, status, tags, milestone, needs_human, prs, position, created_at, updated_at)
-         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
-      )
-      .run(
-        input.title,
-        input.description ?? "",
-        status,
-        JSON.stringify(input.tags ?? []),
-        input.milestone ?? null,
-        input.needsHuman ? 1 : 0,
-        JSON.stringify(input.prs ?? []),
-        (max.max ?? 0) + POSITION_GAP,
-        timestamp,
-        timestamp,
-      )
-    const number = Number(result.lastInsertRowid)
-    if (input.blocks !== undefined) this.reconcileLinks("blocker_id", number, input.blocks)
-    if (input.blockedBy !== undefined) this.reconcileLinks("blocked_id", number, input.blockedBy)
-    return this.get(number)!
-  }
-
-  update(number: number, patch: TaskPatch): Task {
-    const existing = this.get(number)
-    if (!existing) throw new Error(`no such task: ${this.displayId(number)}`)
-
-    // Reconciled outside the UPDATE — links live in their own table. Done
-    // first so a bad target rejects the whole patch before anything writes.
-    let linksChanged = false
-    if (patch.blocks !== undefined) {
-      linksChanged = this.reconcileLinks("blocker_id", number, patch.blocks)
-    }
-    if (patch.blockedBy !== undefined) {
-      linksChanged = this.reconcileLinks("blocked_id", number, patch.blockedBy) || linksChanged
-    }
-
-    const sets: string[] = []
-    const params: (string | number | null)[] = []
-    const set = (column: string, value: string | number | null) => {
-      sets.push(`${column} = ?`)
-      params.push(value)
-    }
-
-    if (patch.title !== undefined) set("title", patch.title)
-    if (patch.description !== undefined) set("description", patch.description)
-    if (patch.tags !== undefined) set("tags", JSON.stringify(patch.tags))
-    if (patch.milestone !== undefined) set("milestone", patch.milestone)
-    if (patch.needsHuman !== undefined) set("needs_human", patch.needsHuman ? 1 : 0)
-    if (patch.prs !== undefined) set("prs", JSON.stringify(patch.prs))
-    if (patch.status !== undefined) {
-      set("status", patch.status)
-      if (patch.position === undefined && patch.status !== existing.status) {
-        // Moved columns without an explicit slot → land on top, where the
-        // freshest movement is visible (Linear's behavior).
-        const min = this.db
-          .prepare("SELECT MIN(position) AS min FROM tasks WHERE status = ?")
-          .get(patch.status) as { min: number | null }
-        set("position", (min.min ?? 0) - POSITION_GAP)
-      }
-    }
-    if (patch.position !== undefined) set("position", patch.position)
-
-    if (sets.length === 0 && !linksChanged) return existing
-    if (sets.length > 0) {
-      set("updated_at", now())
-      params.push(number)
-      this.db.prepare(`UPDATE tasks SET ${sets.join(", ")} WHERE id = ?`).run(...params)
-    }
-    return this.get(number)!
-  }
-
-  /**
-   * Make the link table agree with `targets` for one side of one task —
-   * `blocker_id` when setting what `number` blocks, `blocked_id` when setting
-   * what blocks it. The other task's view is the same row read from the other
-   * end, so there is no second write to keep consistent. Every task touched
-   * (both ends of every added or removed link) gets its `updated_at` bumped.
-   */
-  private reconcileLinks(
-    column: "blocker_id" | "blocked_id",
-    number: number,
-    targets: number[],
-  ): boolean {
-    const other = column === "blocker_id" ? "blocked_id" : "blocker_id"
-    const wanted = [...new Set(targets)]
-    for (const target of wanted) {
-      if (target === number) {
-        throw new Error(`a task can't block itself: ${this.displayId(number)}`)
-      }
-      if (!this.db.prepare("SELECT id FROM tasks WHERE id = ?").get(target)) {
-        throw new Error(`no such task: ${this.displayId(target)}`)
-      }
-    }
-    const current = new Set(this.linkedNumbers(column, number))
-    const removed = [...current].filter((n) => !wanted.includes(n))
-    const added = wanted.filter((n) => !current.has(n))
-    for (const n of removed) {
-      this.db
-        .prepare(`DELETE FROM task_links WHERE ${column} = ? AND ${other} = ?`)
-        .run(number, n)
-    }
-    for (const n of added) {
-      this.db
-        .prepare(`INSERT OR IGNORE INTO task_links (${column}, ${other}) VALUES (?, ?)`)
-        .run(number, n)
-    }
-    const touched = [...removed, ...added]
-    if (touched.length > 0) {
-      const timestamp = now()
-      const bump = this.db.prepare("UPDATE tasks SET updated_at = ? WHERE id = ?")
-      for (const n of [...touched, number]) bump.run(timestamp, n)
-    }
-    return touched.length > 0
-  }
-
-  /** `task link A --blocks B` and friends — additive, unlike the patch form. */
-  link(number: number, relation: "blocks" | "blocked_by", target: number): Task {
-    if (!this.get(number)) throw new Error(`no such task: ${this.displayId(number)}`)
-    const column = relation === "blocks" ? "blocker_id" : "blocked_id"
-    const current = this.linkedNumbers(column, number)
-    this.reconcileLinks(column, number, [...current, target])
-    return this.get(number)!
-  }
-
-  unlink(number: number, relation: "blocks" | "blocked_by", target: number): Task {
-    if (!this.get(number)) throw new Error(`no such task: ${this.displayId(number)}`)
-    const column = relation === "blocks" ? "blocker_id" : "blocked_id"
-    const current = this.linkedNumbers(column, number)
-    this.reconcileLinks(column, number, current.filter((n) => n !== target))
-    return this.get(number)!
-  }
-
-  delete(number: number): void {
-    const result = this.db.prepare("DELETE FROM tasks WHERE id = ?").run(number)
-    if (result.changes === 0) throw new Error(`no such task: ${this.displayId(number)}`)
-  }
-
-  /** The archive is a text-format feature — a directory move, not a table. */
-  archive(_number: number): Task {
-    throw new Error("archiving needs a text-format board — run `task migrate` first")
-  }
-
-  unarchive(_number: number): Task {
-    throw new Error("archiving needs a text-format board — run `task migrate` first")
-  }
-
-  comments(number: number): Comment[] {
-    const rows = this.db
-      .prepare("SELECT * FROM comments WHERE task_id = ? ORDER BY id")
-      .all(number) as unknown as CommentRow[]
-    return rows.map((r) => this.toComment(r))
-  }
-
-  addComment(number: number, body: string, author = ""): Comment {
-    if (!this.get(number)) throw new Error(`no such task: ${this.displayId(number)}`)
-    const result = this.db
-      .prepare("INSERT INTO comments (task_id, author, body, created_at) VALUES (?, ?, ?, ?)")
-      .run(number, author, body, now())
-    const row = this.db
-      .prepare("SELECT * FROM comments WHERE id = ?")
-      .get(Number(result.lastInsertRowid)) as unknown as CommentRow
-    return this.toComment(row)
-  }
-
-  deleteComment(number: number, commentId: string): Comment {
-    const rowid = Number(commentId)
-    const row = (
-      Number.isInteger(rowid)
-        ? this.db
-            .prepare("SELECT * FROM comments WHERE id = ? AND task_id = ?")
-            .get(rowid, number)
-        : undefined
-    ) as CommentRow | undefined
-    if (!row) throw new Error(`no such comment on ${this.displayId(number)}: ${commentId}`)
-    this.db.prepare("DELETE FROM comments WHERE id = ?").run(rowid)
-    return this.toComment(row)
-  }
-
-  commentCounts(): Map<number, number> {
-    const rows = this.db
-      .prepare("SELECT task_id, COUNT(*) AS count FROM comments GROUP BY task_id")
-      .all() as unknown as { task_id: number; count: number }[]
-    return new Map(rows.map((r) => [r.task_id, r.count]))
-  }
-}
-
-/**
- * Schema history, one entry per version, applied in order from whatever
- * `PRAGMA user_version` the file is at. `.task/tasks.db` is committed to git,
- * so an existing database is the normal case, not the exception: every step
- * has to be safe to run against a file someone else's checkout wrote.
- *
- * There is one linear path — a fresh database runs *every* step, so it lands
- * on a schema byte-identical to a migrated one, and there's no second
- * definition of "current" to keep in sync.
- */
-const MIGRATIONS: string[] = [
-  // v1 — the original schema. `IF NOT EXISTS` is load-bearing: user_version 0
-  // means "fresh *or* written before versioning existed", and this is the step
-  // that makes both of those safe to start from.
-  //
-  // The odd indentation is deliberate and load-bearing: SQLite stores the
-  // CREATE statement *verbatim* in sqlite_master, so keeping this byte-for-byte
-  // as it originally shipped is what lets a freshly-created database and a
-  // migrated one end up with an identical schema rather than one that only
-  // matches in structure.
-  `
-    CREATE TABLE IF NOT EXISTS tasks (
-      id INTEGER PRIMARY KEY AUTOINCREMENT,
-      title TEXT NOT NULL,
-      description TEXT NOT NULL DEFAULT '',
-      status TEXT NOT NULL DEFAULT 'todo',
-      priority TEXT NOT NULL DEFAULT 'none',
-      assignee TEXT,
-      labels TEXT NOT NULL DEFAULT '[]',
-      position REAL NOT NULL DEFAULT 0,
-      created_at TEXT NOT NULL,
-      updated_at TEXT NOT NULL
-    );
-    CREATE TABLE IF NOT EXISTS comments (
-      id INTEGER PRIMARY KEY AUTOINCREMENT,
-      task_id INTEGER NOT NULL REFERENCES tasks(id) ON DELETE CASCADE,
-      author TEXT NOT NULL DEFAULT '',
-      body TEXT NOT NULL,
-      created_at TEXT NOT NULL
-    );
-  `,
-
-  // v2 — labels become tags, priority/assignee give way to milestone and a
-  // needs-human flag. RENAME COLUMN (SQLite 3.25+) and DROP COLUMN (3.35+) are
-  // both available on Node ≥ 22.13, which bundles 3.49.
-  //
-  // If DROP COLUMN ever weren't available the escape hatch is the usual table
-  // rebuild — but note it would need `PRAGMA foreign_keys = OFF` issued
-  // *outside* the transaction (the pragma is a no-op inside one), because
-  // comments.task_id references tasks(id).
-  `ALTER TABLE tasks RENAME COLUMN labels TO tags;
-   ALTER TABLE tasks ADD COLUMN milestone TEXT;
-   ALTER TABLE tasks ADD COLUMN needs_human INTEGER NOT NULL DEFAULT 0;
-   ALTER TABLE tasks DROP COLUMN priority;
-   ALTER TABLE tasks DROP COLUMN assignee;`,
-
-  // v3 — dependencies and pull requests. One direction of "blocks" is the
-  // whole relation: (blocker, blocked) read from the blocked side is
-  // "blocked by", so the mirror is a query, not a second row. PRs are a JSON
-  // list of URLs, same shape as tags.
-  `CREATE TABLE task_links (
-     blocker_id INTEGER NOT NULL REFERENCES tasks(id) ON DELETE CASCADE,
-     blocked_id INTEGER NOT NULL REFERENCES tasks(id) ON DELETE CASCADE,
-     PRIMARY KEY (blocker_id, blocked_id)
-   );
-   ALTER TABLE tasks ADD COLUMN prs TEXT NOT NULL DEFAULT '[]';`,
-]
-
-/**
- * Bring `db` up to the newest schema. DDL and `PRAGMA user_version` are both
- * transactional in SQLite, so a failure halfway leaves the file exactly as it
- * was — schema *and* version.
- */
-function migrate(db: DatabaseSync): void {
-  const { user_version: version } = db.prepare("PRAGMA user_version").get() as {
-    user_version: number
-  }
-  if (version >= MIGRATIONS.length) return
-  db.exec("BEGIN")
-  try {
-    for (const step of MIGRATIONS.slice(version)) db.exec(step)
-    db.exec(`PRAGMA user_version = ${MIGRATIONS.length}`)
-    db.exec("COMMIT")
-  } catch (error) {
-    db.exec("ROLLBACK")
-    throw error
-  }
-}
-