@ulpi/cli 0.1.4 → 0.1.6

package/dist/chunk-S6ANCSYO.js

@@ -0,0 +1,1271 @@
+import {
+  extractDescription,
+  githubFetch
+} from "./chunk-76D3BYJD.js";
+
+// ../../packages/tracker-engine/dist/index.js
+import { readFile, writeFile, access, constants } from "fs/promises";
+import { resolve } from "path";
+import { readFile as readFile2, writeFile as writeFile2, access as access2, constants as constants2 } from "fs/promises";
+import { resolve as resolve2 } from "path";
+var BaseTrackerPlugin = class {
+  config = {};
+  ready = false;
+  async initialize(config) {
+    this.config = config;
+    this.ready = true;
+  }
+  async isReady() {
+    return this.ready;
+  }
+  async getTask(id) {
+    const tasks = await this.getTasks();
+    return tasks.find((t) => t.id === id);
+  }
+  /**
+   * Get the next task to work on.
+   * 1. Gets all open/in_progress tasks
+   * 2. Filters to ready tasks (no unresolved dependencies)
+   * 3. Sorts by priority (lowest number = highest priority)
+   * 4. Prefers in_progress tasks over open tasks
+   */
+  async getNextTask(filter) {
+    const mergedFilter = {
+      ...filter,
+      status: ["open", "in_progress"],
+      ready: true
+    };
+    const tasks = await this.getTasks(mergedFilter);
+    if (tasks.length === 0) return void 0;
+    tasks.sort((a, b) => a.priority - b.priority);
+    const inProgress = tasks.find((t) => t.status === "in_progress");
+    if (inProgress) return inProgress;
+    return tasks[0];
+  }
+  async isComplete(filter) {
+    const tasks = await this.getTasks(filter);
+    return tasks.every(
+      (t) => t.status === "done" || t.status === "skipped"
+    );
+  }
+  async isTaskReady(id) {
+    const task = await this.getTask(id);
+    if (!task) return false;
+    const allTasks = await this.getTasks();
+    return this.checkTaskReady(task, allTasks);
+  }
+  async sync() {
+    return {
+      success: true,
+      message: "Sync not required for this tracker",
+      syncedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+  }
+  getTemplate() {
+    return `## Task
+**ID**: {{taskId}}
+**Title**: {{taskTitle}}
+
+{{#if taskDescription}}
+## Description
+{{taskDescription}}
+{{/if}}
+
+{{#if dependsOn}}
+**Dependencies**: {{dependsOn}}
+{{/if}}
+
+## Instructions
+Complete the task described above.
+When finished, signal completion.
+`;
+  }
+  async dispose() {
+    this.ready = false;
+  }
+  // ─── Helper methods for subclasses ───
+  /**
+   * Filter tasks by the given criteria.
+   */
+  filterTasks(tasks, filter) {
+    if (!filter) return tasks;
+    let result = tasks;
+    if (filter.status) {
+      const statuses = Array.isArray(filter.status) ? filter.status : [filter.status];
+      result = result.filter((t) => statuses.includes(t.status));
+    }
+    if (filter.labels && filter.labels.length > 0) {
+      result = result.filter(
+        (t) => filter.labels.every((label) => t.labels?.includes(label))
+      );
+    }
+    if (filter.priority !== void 0) {
+      const priorities = Array.isArray(filter.priority) ? filter.priority : [filter.priority];
+      result = result.filter(
+        (t) => priorities.includes(t.priority)
+      );
+    }
+    if (filter.parentId) {
+      result = result.filter((t) => t.parentId === filter.parentId);
+    }
+    if (filter.assignee) {
+      result = result.filter((t) => t.assignee === filter.assignee);
+    }
+    if (filter.type) {
+      const types = Array.isArray(filter.type) ? filter.type : [filter.type];
+      result = result.filter((t) => t.type && types.includes(t.type));
+    }
+    if (filter.excludeIds && filter.excludeIds.length > 0) {
+      const excludeSet = new Set(filter.excludeIds);
+      result = result.filter((t) => !excludeSet.has(t.id));
+    }
+    if (filter.ready) {
+      result = result.filter((t) => this.checkTaskReady(t, tasks));
+    }
+    if (filter.offset && filter.offset > 0) {
+      result = result.slice(filter.offset);
+    }
+    if (filter.limit && filter.limit > 0) {
+      result = result.slice(0, filter.limit);
+    }
+    return result;
+  }
+  /**
+   * Check if a task is ready (all dependencies resolved).
+   */
+  checkTaskReady(task, allTasks) {
+    if (!task.dependsOn || task.dependsOn.length === 0) return true;
+    return task.dependsOn.every((depId) => {
+      const depTask = allTasks.find((t) => t.id === depId);
+      return !depTask || depTask.status === "done" || depTask.status === "skipped";
+    });
+  }
+};
+function clampPriority(p) {
+  if (p === void 0) return 2;
+  return Math.max(0, Math.min(4, p));
+}
+function jsonTaskToTrackerTask(task) {
+  return {
+    id: task.id,
+    title: task.title,
+    status: task.status,
+    priority: clampPriority(task.priority),
+    description: task.description,
+    labels: task.labels,
+    type: task.type,
+    parentId: task.parentId,
+    dependsOn: task.dependsOn,
+    blocks: task.blocks,
+    assignee: task.assignee,
+    metadata: task.metadata
+  };
+}
+var JsonTrackerPlugin = class extends BaseTrackerPlugin {
+  meta = {
+    id: "json",
+    name: "JSON File Tracker",
+    description: "Track tasks in a local tasks.json file",
+    version: "1.0.0",
+    supportsBidirectionalSync: false,
+    supportsHierarchy: true,
+    supportsDependencies: true
+  };
+  filePath = "";
+  cache = null;
+  cacheTime = 0;
+  CACHE_TTL_MS = 1e3;
+  async initialize(config) {
+    await super.initialize(config);
+    if (typeof config.path === "string") {
+      this.filePath = resolve(config.path);
+    }
+    if (this.filePath) {
+      try {
+        await access(this.filePath, constants.R_OK | constants.W_OK);
+        this.ready = true;
+      } catch {
+        this.ready = false;
+      }
+    }
+  }
+  async isReady() {
+    if (!this.filePath) return false;
+    try {
+      await access(this.filePath, constants.R_OK | constants.W_OK);
+      this.ready = true;
+      return true;
+    } catch {
+      this.ready = false;
+      return false;
+    }
+  }
+  async readTasksFile() {
+    const now = Date.now();
+    if (this.cache && now - this.cacheTime < this.CACHE_TTL_MS) {
+      return this.cache;
+    }
+    const content = await readFile(this.filePath, "utf-8");
+    const parsed = JSON.parse(content);
+    this.cache = parsed;
+    this.cacheTime = now;
+    return parsed;
+  }
+  async writeTasksFile(data) {
+    if (!data.metadata) data.metadata = {};
+    data.metadata.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+    const content = JSON.stringify(data, null, 2);
+    await writeFile(this.filePath, content, "utf-8");
+    this.cache = data;
+    this.cacheTime = Date.now();
+  }
+  async getTasks(filter) {
+    if (!this.filePath) return [];
+    try {
+      const data = await this.readTasksFile();
+      const tasks = data.tasks.map(jsonTaskToTrackerTask);
+      return this.filterTasks(tasks, filter);
+    } catch {
+      return [];
+    }
+  }
+  async completeTask(id, result) {
+    try {
+      this.cache = null;
+      const data = await this.readTasksFile();
+      const taskIndex = data.tasks.findIndex((t) => t.id === id);
+      if (taskIndex === -1) {
+        return { success: false, message: `Task ${id} not found`, error: "Not found" };
+      }
+      const task = data.tasks[taskIndex];
+      task.status = "done";
+      if (result?.summary) {
+        if (!task.metadata) task.metadata = {};
+        task.metadata.completionSummary = result.summary;
+      }
+      await this.writeTasksFile(data);
+      return { success: true, message: `Task ${id} marked as done` };
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      return { success: false, message: `Failed to complete task ${id}`, error: message };
+    }
+  }
+  async updateTaskStatus(id, status) {
+    try {
+      this.cache = null;
+      const data = await this.readTasksFile();
+      const taskIndex = data.tasks.findIndex((t) => t.id === id);
+      if (taskIndex === -1) return void 0;
+      const task = data.tasks[taskIndex];
+      task.status = status;
+      await this.writeTasksFile(data);
+      return jsonTaskToTrackerTask(task);
+    } catch {
+      return void 0;
+    }
+  }
+  getStateFiles() {
+    if (this.filePath) return [this.filePath];
+    return [];
+  }
+  getFilePath() {
+    return this.filePath;
+  }
+};
+var createJsonTracker = () => new JsonTrackerPlugin();
+var json_default = createJsonTracker;
+function mapGitHubStatus(state) {
+  return state === "closed" ? "done" : "open";
+}
+function mapPriorityFromLabels(labels) {
+  for (const label of labels) {
+    const name = label.name.toLowerCase();
+    if (name === "p0" || name === "critical") return 0;
+    if (name === "p1" || name === "high") return 1;
+    if (name === "p2" || name === "medium") return 2;
+    if (name === "p3" || name === "low") return 3;
+    if (name === "p4" || name === "backlog") return 4;
+  }
+  return 2;
+}
+function mapTypeFromLabels(labels) {
+  for (const label of labels) {
+    const name = label.name.toLowerCase();
+    if (name === "bug") return "bug";
+    if (name === "feature" || name === "enhancement") return "feature";
+    if (name === "task") return "task";
+    if (name === "epic") return "epic";
+  }
+  return void 0;
+}
+function issueToTask(issue, repo) {
+  return {
+    id: `${repo}#${issue.number}`,
+    title: issue.title,
+    status: mapGitHubStatus(issue.state),
+    priority: mapPriorityFromLabels(issue.labels),
+    description: issue.body ?? void 0,
+    labels: issue.labels.map((l) => l.name),
+    type: mapTypeFromLabels(issue.labels),
+    assignee: issue.assignee?.login,
+    createdAt: issue.created_at,
+    updatedAt: issue.updated_at,
+    metadata: {
+      number: issue.number,
+      repo,
+      milestone: issue.milestone?.title
+    }
+  };
+}
+var GitHubTrackerPlugin = class extends BaseTrackerPlugin {
+  meta = {
+    id: "github",
+    name: "GitHub Issues Tracker",
+    description: "Track tasks via GitHub Issues",
+    version: "1.0.0",
+    supportsBidirectionalSync: true,
+    supportsHierarchy: false,
+    supportsDependencies: true
+  };
+  token = "";
+  repo = "";
+  async initialize(config) {
+    await super.initialize(config);
+    if (typeof config.token === "string") {
+      this.token = config.token;
+    }
+    if (typeof config.repo === "string") {
+      this.repo = config.repo;
+    }
+    this.ready = Boolean(this.token && this.repo);
+  }
+  async fetchIssues(state = "all") {
+    const response = await githubFetch(
+      `/repos/${this.repo}/issues?state=${state}&per_page=100`,
+      this.token
+    );
+    const data = await response.json();
+    return data.filter((issue) => !("pull_request" in issue));
+  }
+  async getTasks(filter) {
+    try {
+      const issues = await this.fetchIssues();
+      const tasks = issues.map((issue) => issueToTask(issue, this.repo));
+      return this.filterTasks(tasks, filter);
+    } catch {
+      return [];
+    }
+  }
+  async completeTask(id, _result) {
+    try {
+      const issueNumber = this.extractIssueNumber(id);
+      if (!issueNumber) {
+        return { success: false, message: `Invalid issue ID: ${id}`, error: "Invalid ID" };
+      }
+      await githubFetch(
+        `/repos/${this.repo}/issues/${issueNumber}`,
+        this.token,
+        {
+          method: "PATCH",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({ state: "closed" })
+        }
+      );
+      return { success: true, message: `Issue #${issueNumber} closed` };
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      return { success: false, message: `Failed to complete task`, error: message };
+    }
+  }
+  async updateTaskStatus(id, status) {
+    try {
+      const issueNumber = this.extractIssueNumber(id);
+      if (!issueNumber) return void 0;
+      const ghState = status === "done" || status === "skipped" ? "closed" : "open";
+      const response = await githubFetch(
+        `/repos/${this.repo}/issues/${issueNumber}`,
+        this.token,
+        {
+          method: "PATCH",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({ state: ghState })
+        }
+      );
+      const issue = await response.json();
+      return issueToTask(issue, this.repo);
+    } catch {
+      return void 0;
+    }
+  }
+  async sync() {
+    try {
+      const issues = await this.fetchIssues();
+      return {
+        success: true,
+        message: `Synced ${issues.length} issues from ${this.repo}`,
+        updated: issues.length,
+        syncedAt: (/* @__PURE__ */ new Date()).toISOString()
+      };
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      return {
+        success: false,
+        message: "Sync failed",
+        error: message,
+        syncedAt: (/* @__PURE__ */ new Date()).toISOString()
+      };
+    }
+  }
+  extractIssueNumber(id) {
+    const match = id.match(/#(\d+)$/);
+    return match ? parseInt(match[1], 10) : null;
+  }
+};
+var createGitHubTracker = () => new GitHubTrackerPlugin();
+var github_default = createGitHubTracker;
+function mapJiraStatus(statusCategory) {
+  switch (statusCategory) {
+    case "done":
+      return "done";
+    case "indeterminate":
+      return "in_progress";
+    case "new":
+    default:
+      return "open";
+  }
+}
+function mapJiraPriority(priorityName) {
+  if (!priorityName) return 2;
+  const name = priorityName.toLowerCase();
+  if (name === "highest" || name === "blocker" || name === "critical") return 0;
+  if (name === "high") return 1;
+  if (name === "medium" || name === "normal") return 2;
+  if (name === "low") return 3;
+  if (name === "lowest" || name === "trivial") return 4;
+  return 2;
+}
+function mapJiraType(issuetypeName) {
+  const name = issuetypeName.toLowerCase();
+  if (name === "bug") return "bug";
+  if (name === "story" || name === "feature") return "feature";
+  if (name === "epic") return "epic";
+  if (name === "task" || name === "sub-task" || name === "subtask") return "task";
+  return name;
+}
+function jiraIssueToTask(issue, project) {
+  const { fields } = issue;
+  const dependsOn = [];
+  const blocks = [];
+  for (const link of fields.issuelinks) {
+    if (link.type.inward.toLowerCase().includes("blocked by") && link.inwardIssue) {
+      dependsOn.push(link.inwardIssue.key);
+    }
+    if (link.type.outward.toLowerCase().includes("blocks") && link.outwardIssue) {
+      blocks.push(link.outwardIssue.key);
+    }
+  }
+  return {
+    id: issue.key,
+    title: fields.summary,
+    status: mapJiraStatus(fields.status.statusCategory.key),
+    priority: mapJiraPriority(fields.priority?.name),
+    description: extractDescription(fields.description),
+    labels: fields.labels,
+    type: mapJiraType(fields.issuetype.name),
+    parentId: fields.parent?.key,
+    dependsOn: dependsOn.length > 0 ? dependsOn : void 0,
+    blocks: blocks.length > 0 ? blocks : void 0,
+    assignee: fields.assignee?.displayName,
+    createdAt: fields.created,
+    updatedAt: fields.updated,
+    metadata: {
+      project,
+      statusName: fields.status.name,
+      issuetype: fields.issuetype.name,
+      isSubtask: fields.issuetype.subtask
+    }
+  };
+}
+var JiraTrackerPlugin = class extends BaseTrackerPlugin {
+  meta = {
+    id: "jira",
+    name: "Jira Tracker",
+    description: "Track tasks via Jira Issues (REST API v3)",
+    version: "1.0.0",
+    supportsBidirectionalSync: true,
+    supportsHierarchy: true,
+    supportsDependencies: true
+  };
+  baseUrl = "";
+  email = "";
+  apiToken = "";
+  project = "";
+  jql = "";
+  async initialize(config) {
+    await super.initialize(config);
+    if (typeof config.baseUrl === "string") {
+      this.baseUrl = config.baseUrl.replace(/\/$/, "");
+    }
+    if (typeof config.email === "string") {
+      this.email = config.email;
+    }
+    if (typeof config.apiToken === "string") {
+      this.apiToken = config.apiToken;
+    }
+    if (typeof config.project === "string") {
+      this.project = config.project;
+    }
+    if (typeof config.jql === "string") {
+      this.jql = config.jql;
+    }
+    this.ready = Boolean(this.baseUrl && this.email && this.apiToken && this.project);
+  }
+  getAuthHeader() {
+    return `Basic ${Buffer.from(`${this.email}:${this.apiToken}`).toString("base64")}`;
+  }
+  async searchIssues(jql, startAt = 0) {
+    const url = `${this.baseUrl}/rest/api/3/search`;
+    const response = await fetch(url, {
+      method: "POST",
+      headers: {
+        Authorization: this.getAuthHeader(),
+        Accept: "application/json",
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({
+        jql,
+        startAt,
+        maxResults: 100,
+        fields: [
+          "summary",
+          "description",
+          "status",
+          "priority",
+          "labels",
+          "assignee",
+          "issuetype",
+          "parent",
+          "issuelinks",
+          "created",
+          "updated"
+        ]
+      })
+    });
+    if (!response.ok) {
+      throw new Error(`Jira API error: ${response.status} ${response.statusText}`);
+    }
+    return await response.json();
+  }
+  async fetchAllIssues() {
+    const jql = this.jql || `project = "${this.project}" ORDER BY rank ASC`;
+    const allIssues = [];
+    let startAt = 0;
+    while (true) {
+      const result = await this.searchIssues(jql, startAt);
+      allIssues.push(...result.issues);
+      if (startAt + result.maxResults >= result.total) break;
+      startAt += result.maxResults;
+    }
+    return allIssues;
+  }
+  async getTasks(filter) {
+    try {
+      const issues = await this.fetchAllIssues();
+      const tasks = issues.map((issue) => jiraIssueToTask(issue, this.project));
+      return this.filterTasks(tasks, filter);
+    } catch {
+      return [];
+    }
+  }
+  async completeTask(id, _result) {
+    try {
+      const transUrl = `${this.baseUrl}/rest/api/3/issue/${encodeURIComponent(id)}/transitions`;
+      const transResponse = await fetch(transUrl, {
+        headers: {
+          Authorization: this.getAuthHeader(),
+          Accept: "application/json"
+        }
+      });
+      if (!transResponse.ok) {
+        return {
+          success: false,
+          message: `Failed to get transitions for ${id}`,
+          error: `Jira API error: ${transResponse.status}`
+        };
+      }
+      const transData = await transResponse.json();
+      const doneTransition = transData.transitions.find(
+        (t) => t.to.statusCategory.key === "done"
+      );
+      if (!doneTransition) {
+        return {
+          success: false,
+          message: `No "Done" transition available for ${id}`,
+          error: "No done transition found"
+        };
+      }
+      const response = await fetch(transUrl, {
+        method: "POST",
+        headers: {
+          Authorization: this.getAuthHeader(),
+          Accept: "application/json",
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify({ transition: { id: doneTransition.id } })
+      });
+      if (!response.ok) {
+        return {
+          success: false,
+          message: `Failed to transition ${id} to Done`,
+          error: `Jira API error: ${response.status}`
+        };
+      }
+      return { success: true, message: `${id} transitioned to Done` };
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      return { success: false, message: `Failed to complete task`, error: message };
+    }
+  }
+  async updateTaskStatus(id, status) {
+    try {
+      const transUrl = `${this.baseUrl}/rest/api/3/issue/${encodeURIComponent(id)}/transitions`;
+      const transResponse = await fetch(transUrl, {
+        headers: {
+          Authorization: this.getAuthHeader(),
+          Accept: "application/json"
+        }
+      });
+      if (!transResponse.ok) return void 0;
+      const transData = await transResponse.json();
+      const targetCategory = status === "done" || status === "skipped" ? "done" : status === "in_progress" ? "indeterminate" : "new";
+      const transition = transData.transitions.find(
+        (t) => t.to.statusCategory.key === targetCategory
+      );
+      if (!transition) return void 0;
+      const response = await fetch(transUrl, {
+        method: "POST",
+        headers: {
+          Authorization: this.getAuthHeader(),
+          Accept: "application/json",
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify({ transition: { id: transition.id } })
+      });
+      if (!response.ok) return void 0;
+      const issueUrl = `${this.baseUrl}/rest/api/3/issue/${encodeURIComponent(id)}`;
+      const issueResponse = await fetch(issueUrl, {
+        headers: {
+          Authorization: this.getAuthHeader(),
+          Accept: "application/json"
+        }
+      });
+      if (!issueResponse.ok) return void 0;
+      const issue = await issueResponse.json();
+      return jiraIssueToTask(issue, this.project);
+    } catch {
+      return void 0;
+    }
+  }
+  async sync() {
+    try {
+      const issues = await this.fetchAllIssues();
+      return {
+        success: true,
+        message: `Synced ${issues.length} issues from Jira project ${this.project}`,
+        updated: issues.length,
+        syncedAt: (/* @__PURE__ */ new Date()).toISOString()
+      };
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      return {
+        success: false,
+        message: "Sync failed",
+        error: message,
+        syncedAt: (/* @__PURE__ */ new Date()).toISOString()
+      };
+    }
+  }
+};
+var createJiraTracker = () => new JiraTrackerPlugin();
+var jira_default = createJiraTracker;
+var ISSUES_QUERY = `
+  query Issues($teamKey: String!, $after: String) {
+    issues(
+      filter: { team: { key: { eq: $teamKey } } }
+      first: 100
+      after: $after
+      orderBy: priority
+    ) {
+      nodes {
+        id
+        identifier
+        title
+        description
+        state { name type }
+        priority
+        labels { nodes { name } }
+        assignee { name email }
+        parent { identifier }
+        relations { nodes { type relatedIssue { identifier } } }
+        createdAt
+        updatedAt
+      }
+      pageInfo { hasNextPage endCursor }
+    }
+  }
+`;
+var UPDATE_STATE_MUTATION = `
+  mutation UpdateIssue($issueId: String!, $stateId: String!) {
+    issueUpdate(id: $issueId, input: { stateId: $stateId }) {
+      success
+      issue {
+        id
+        identifier
+        title
+        description
+        state { name type }
+        priority
+        labels { nodes { name } }
+        assignee { name email }
+        parent { identifier }
+        relations { nodes { type relatedIssue { identifier } } }
+        createdAt
+        updatedAt
+      }
+    }
+  }
+`;
+var WORKFLOW_STATES_QUERY = `
+  query WorkflowStates($teamKey: String!) {
+    team(key: $teamKey) { id }
+    workflowStates(filter: { team: { key: { eq: $teamKey } } }) {
+      nodes { id name type }
+    }
+  }
+`;
+function mapLinearStatus(stateType) {
+  switch (stateType) {
+    case "completed":
+      return "done";
+    case "cancelled":
+      return "skipped";
+    case "started":
+      return "in_progress";
+    case "unstarted":
+    case "backlog":
+    case "triage":
+    default:
+      return "open";
+  }
+}
+function mapLinearPriority(priority) {
+  switch (priority) {
+    case 1:
+      return 0;
+    // Urgent -> P0
+    case 2:
+      return 1;
+    // High -> P1
+    case 3:
+      return 2;
+    // Medium -> P2
+    case 4:
+      return 3;
+    // Low -> P3
+    case 0:
+    default:
+      return 2;
+  }
+}
+function linearIssueToTask(issue) {
+  const dependsOn = [];
+  const blocks = [];
+  for (const rel of issue.relations.nodes) {
+    if (rel.type === "blocks") {
+      blocks.push(rel.relatedIssue.identifier);
+    } else if (rel.type === "blocked") {
+      dependsOn.push(rel.relatedIssue.identifier);
+    }
+  }
+  return {
+    id: issue.identifier,
+    title: issue.title,
+    status: mapLinearStatus(issue.state.type),
+    priority: mapLinearPriority(issue.priority),
+    description: issue.description ?? void 0,
+    labels: issue.labels.nodes.map((l) => l.name),
+    parentId: issue.parent?.identifier,
+    dependsOn: dependsOn.length > 0 ? dependsOn : void 0,
+    blocks: blocks.length > 0 ? blocks : void 0,
+    assignee: issue.assignee?.name,
+    createdAt: issue.createdAt,
+    updatedAt: issue.updatedAt,
+    metadata: {
+      linearId: issue.id,
+      stateName: issue.state.name,
+      stateType: issue.state.type
+    }
+  };
+}
+var LinearTrackerPlugin = class extends BaseTrackerPlugin {
+  meta = {
+    id: "linear",
+    name: "Linear Tracker",
+    description: "Track tasks via Linear Issues (GraphQL API)",
+    version: "1.0.0",
+    supportsBidirectionalSync: true,
+    supportsHierarchy: true,
+    supportsDependencies: true
+  };
+  apiKey = "";
+  teamKey = "";
+  apiUrl = "https://api.linear.app/graphql";
+  // Cached workflow states for the team
+  workflowStates = [];
+  async initialize(config) {
+    await super.initialize(config);
+    if (typeof config.apiKey === "string") {
+      this.apiKey = config.apiKey;
+    }
+    if (typeof config.teamKey === "string") {
+      this.teamKey = config.teamKey;
+    }
+    if (typeof config.apiUrl === "string") {
+      this.apiUrl = config.apiUrl;
+    }
+    this.ready = Boolean(this.apiKey && this.teamKey);
+    if (this.ready) {
+      try {
+        await this.loadWorkflowStates();
+      } catch {
+      }
+    }
+  }
+  async graphql(query, variables) {
+    const response = await fetch(this.apiUrl, {
+      method: "POST",
+      headers: {
+        Authorization: this.apiKey,
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({ query, variables })
+    });
+    if (!response.ok) {
+      throw new Error(`Linear API error: ${response.status} ${response.statusText}`);
+    }
+    const result = await response.json();
+    if (result.errors && result.errors.length > 0) {
+      throw new Error(`Linear GraphQL error: ${result.errors[0].message}`);
+    }
+    return result;
+  }
+  async loadWorkflowStates() {
+    const result = await this.graphql(WORKFLOW_STATES_QUERY, { teamKey: this.teamKey });
+    this.workflowStates = result.data?.workflowStates?.nodes ?? [];
+  }
+  async fetchAllIssues() {
+    const allIssues = [];
+    let cursor = null;
+    while (true) {
+      const variables = { teamKey: this.teamKey };
+      if (cursor) variables.after = cursor;
+      const result = await this.graphql(ISSUES_QUERY, variables);
+      const issues = result.data?.issues;
+      if (!issues) break;
+      allIssues.push(...issues.nodes);
+      if (!issues.pageInfo.hasNextPage) break;
+      cursor = issues.pageInfo.endCursor;
+    }
+    return allIssues;
+  }
+  async findWorkflowState(targetType) {
+    if (this.workflowStates.length === 0) {
+      await this.loadWorkflowStates();
+    }
+    return this.workflowStates.find((s) => s.type === targetType);
+  }
+  async getTasks(filter) {
+    try {
+      const issues = await this.fetchAllIssues();
+      const tasks = issues.map(linearIssueToTask);
+      return this.filterTasks(tasks, filter);
+    } catch {
+      return [];
+    }
+  }
+  async completeTask(id, _result) {
+    try {
+      const doneState = await this.findWorkflowState("completed");
+      if (!doneState) {
+        return {
+          success: false,
+          message: `No "completed" workflow state found for team ${this.teamKey}`,
+          error: "No completed state"
+        };
+      }
+      const issues = await this.fetchAllIssues();
+      const issue = issues.find((i) => i.identifier === id);
+      if (!issue) {
+        return { success: false, message: `Issue ${id} not found`, error: "Not found" };
+      }
+      const result = await this.graphql(UPDATE_STATE_MUTATION, {
+        issueId: issue.id,
+        stateId: doneState.id
+      });
+      if (!result.data?.issueUpdate?.success) {
+        return { success: false, message: `Failed to complete ${id}`, error: "Update failed" };
+      }
+      return { success: true, message: `${id} marked as completed` };
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      return { success: false, message: `Failed to complete task`, error: message };
+    }
+  }
+  async updateTaskStatus(id, status) {
+    try {
+      const targetType = status === "done" ? "completed" : status === "skipped" ? "cancelled" : status === "in_progress" ? "started" : "unstarted";
+      const targetState = await this.findWorkflowState(targetType);
+      if (!targetState) return void 0;
+      const issues = await this.fetchAllIssues();
+      const issue = issues.find((i) => i.identifier === id);
+      if (!issue) return void 0;
+      const result = await this.graphql(UPDATE_STATE_MUTATION, {
+        issueId: issue.id,
+        stateId: targetState.id
+      });
+      if (!result.data?.issueUpdate?.success) return void 0;
+      return linearIssueToTask(result.data.issueUpdate.issue);
+    } catch {
+      return void 0;
+    }
+  }
+  async sync() {
+    try {
+      const issues = await this.fetchAllIssues();
+      return {
+        success: true,
+        message: `Synced ${issues.length} issues from Linear team ${this.teamKey}`,
+        updated: issues.length,
+        syncedAt: (/* @__PURE__ */ new Date()).toISOString()
+      };
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      return {
+        success: false,
+        message: "Sync failed",
+        error: message,
+        syncedAt: (/* @__PURE__ */ new Date()).toISOString()
+      };
+    }
+  }
+};
+var createLinearTracker = () => new LinearTrackerPlugin();
+var linear_default = createLinearTracker;
+function extractTaskId(text, lineIndex) {
+  const bracketMatch = text.match(/^\[([^\]]+)\]\s*/);
+  if (bracketMatch) return bracketMatch[1];
+  const commentMatch = text.match(/<!--\s*id:\s*([^\s]+)\s*-->/);
+  if (commentMatch) return commentMatch[1];
+  return `md-L${lineIndex + 1}`;
+}
+function extractDependencies(text) {
+  const match = text.match(/<!--\s*depends:\s*(.+?)\s*-->/);
+  if (!match) return [];
+  return match[1].split(",").map((s) => s.trim()).filter(Boolean);
+}
+function extractPriority(text) {
+  const match = text.match(/<!--\s*priority:\s*(\d)\s*-->/);
+  if (!match) return 2;
+  const p = parseInt(match[1], 10);
+  return Math.max(0, Math.min(4, p));
+}
+function extractLabels(text) {
+  const match = text.match(/<!--\s*labels:\s*(.+?)\s*-->/);
+  if (!match) return [];
+  return match[1].split(",").map((s) => s.trim()).filter(Boolean);
+}
+function extractType(text) {
+  const match = text.match(/<!--\s*type:\s*(\w+)\s*-->/);
+  return match ? match[1] : void 0;
+}
+function cleanTaskTitle(text) {
+  return text.replace(/^\[([^\]]+)\]\s*/, "").replace(/<!--[^>]*-->/g, "").trim();
+}
+function parseChecklist(content) {
+  const lines = content.split("\n");
+  const items = [];
+  let currentHeading;
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    const headingMatch = line.match(/^(#{1,6})\s+(.+)/);
+    if (headingMatch) {
+      currentHeading = headingMatch[2].trim();
+      continue;
+    }
+    const checkMatch = line.match(/^(\s*)- \[([ xX])\]\s+(.+)/);
+    if (!checkMatch) continue;
+    const text = checkMatch[3];
+    const checked = checkMatch[2] !== " ";
+    items.push({
+      lineIndex: i,
+      checked,
+      text,
+      id: extractTaskId(text, i),
+      dependsOn: extractDependencies(text),
+      priority: extractPriority(text),
+      labels: extractLabels(text),
+      type: extractType(text),
+      parentHeading: currentHeading
+    });
+  }
+  return items;
+}
+function checklistItemToTask(item, allItems) {
+  let parentId;
+  if (item.parentHeading) {
+    const parentItem = allItems.find(
+      (other) => other !== item && cleanTaskTitle(other.text) === item.parentHeading
+    );
+    if (parentItem) {
+      parentId = parentItem.id;
+    }
+  }
+  return {
+    id: item.id,
+    title: cleanTaskTitle(item.text),
+    status: item.checked ? "done" : "open",
+    priority: item.priority,
+    labels: item.labels.length > 0 ? item.labels : void 0,
+    type: item.type,
+    parentId,
+    dependsOn: item.dependsOn.length > 0 ? item.dependsOn : void 0,
+    metadata: {
+      lineIndex: item.lineIndex,
+      heading: item.parentHeading
+    }
+  };
+}
+var MarkdownTrackerPlugin = class extends BaseTrackerPlugin {
+  meta = {
+    id: "markdown",
+    name: "Markdown Checklist Tracker",
+    description: "Track tasks from markdown checklist files",
+    version: "1.0.0",
+    supportsBidirectionalSync: false,
+    supportsHierarchy: true,
+    supportsDependencies: true
+  };
+  filePath = "";
+  cache = null;
+  cacheTime = 0;
+  CACHE_TTL_MS = 1e3;
+  async initialize(config) {
+    await super.initialize(config);
+    if (typeof config.path === "string") {
+      this.filePath = resolve2(config.path);
+    }
+    if (this.filePath) {
+      try {
+        await access2(this.filePath, constants2.R_OK | constants2.W_OK);
+        this.ready = true;
+      } catch {
+        this.ready = false;
+      }
+    }
+  }
+  async isReady() {
+    if (!this.filePath) return false;
+    try {
+      await access2(this.filePath, constants2.R_OK | constants2.W_OK);
+      this.ready = true;
+      return true;
+    } catch {
+      this.ready = false;
+      return false;
+    }
+  }
+  async readAndParse() {
+    const now = Date.now();
+    if (this.cache && now - this.cacheTime < this.CACHE_TTL_MS) {
+      return this.cache;
+    }
+    const content = await readFile2(this.filePath, "utf-8");
+    const items = parseChecklist(content);
+    this.cache = { content, items };
+    this.cacheTime = now;
+    return this.cache;
+  }
+  async writeContent(content) {
+    await writeFile2(this.filePath, content, "utf-8");
+    this.cache = null;
+  }
+  /**
+   * Toggle a checklist item in the raw markdown content.
+   */
+  toggleChecklistItem(content, lineIndex, checked) {
+    const lines = content.split("\n");
+    const line = lines[lineIndex];
+    if (!line) return content;
+    const replacement = checked ? "[x]" : "[ ]";
+    lines[lineIndex] = line.replace(/\[([ xX])\]/, replacement);
+    return lines.join("\n");
+  }
+  async getTasks(filter) {
+    if (!this.filePath) return [];
+    try {
+      const { items } = await this.readAndParse();
+      const tasks = items.map((item) => checklistItemToTask(item, items));
+      return this.filterTasks(tasks, filter);
+    } catch {
+      return [];
+    }
+  }
+  async completeTask(id, _result) {
+    try {
+      this.cache = null;
+      const { content, items } = await this.readAndParse();
+      const item = items.find((i) => i.id === id);
+      if (!item) {
+        return { success: false, message: `Task ${id} not found`, error: "Not found" };
+      }
+      const newContent = this.toggleChecklistItem(content, item.lineIndex, true);
+      await this.writeContent(newContent);
+      return { success: true, message: `Task ${id} marked as done` };
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      return { success: false, message: `Failed to complete task ${id}`, error: message };
+    }
+  }
+  async updateTaskStatus(id, status) {
+    try {
+      this.cache = null;
+      const { content, items } = await this.readAndParse();
+      const item = items.find((i) => i.id === id);
+      if (!item) return void 0;
+      const checked = status === "done" || status === "skipped";
+      const newContent = this.toggleChecklistItem(content, item.lineIndex, checked);
+      await this.writeContent(newContent);
+      const updated = await this.readAndParse();
+      const updatedItem = updated.items.find((i) => i.id === id);
+      if (!updatedItem) return void 0;
+      return checklistItemToTask(updatedItem, updated.items);
+    } catch {
+      return void 0;
+    }
+  }
+  getStateFiles() {
+    if (this.filePath) return [this.filePath];
+    return [];
+  }
+  getFilePath() {
+    return this.filePath;
+  }
+};
+var createMarkdownTracker = () => new MarkdownTrackerPlugin();
+var markdown_default = createMarkdownTracker;
+var TrackerRegistry = class _TrackerRegistry {
+  static instance = null;
+  plugins = /* @__PURE__ */ new Map();
+  loadedInstances = /* @__PURE__ */ new Map();
+  initialized = false;
+  constructor() {
+  }
+  static getInstance() {
+    if (!_TrackerRegistry.instance) {
+      _TrackerRegistry.instance = new _TrackerRegistry();
+    }
+    return _TrackerRegistry.instance;
+  }
+  static resetInstance() {
+    if (_TrackerRegistry.instance) {
+      for (const instance of _TrackerRegistry.instance.loadedInstances.values()) {
+        instance.dispose().catch(() => {
+        });
+      }
+      _TrackerRegistry.instance.plugins.clear();
+      _TrackerRegistry.instance.loadedInstances.clear();
+      _TrackerRegistry.instance.initialized = false;
+    }
+    _TrackerRegistry.instance = null;
+  }
+  registerBuiltin(factory) {
+    const instance = factory();
+    const { meta } = instance;
+    this.plugins.set(meta.id, { factory, meta, builtin: true });
+    instance.dispose().catch(() => {
+    });
+  }
+  getRegisteredPlugins() {
+    return Array.from(this.plugins.values()).map((p) => p.meta);
+  }
+  getPluginMeta(pluginId) {
+    return this.plugins.get(pluginId)?.meta;
+  }
+  hasPlugin(pluginId) {
+    return this.plugins.has(pluginId);
+  }
+  createInstance(pluginId) {
+    const registered = this.plugins.get(pluginId);
+    if (!registered) return void 0;
+    return registered.factory();
+  }
+  async getInstance(config) {
+    const cacheKey = config.name;
+    const cached = this.loadedInstances.get(cacheKey);
+    if (cached) return cached;
+    const instance = this.createInstance(config.plugin);
+    if (!instance) {
+      throw new Error(`Unknown tracker plugin: ${config.plugin}`);
+    }
+    await instance.initialize(config.options);
+    this.loadedInstances.set(cacheKey, instance);
+    return instance;
+  }
+  async disposeInstance(configName) {
+    const instance = this.loadedInstances.get(configName);
+    if (instance) {
+      await instance.dispose();
+      this.loadedInstances.delete(configName);
+    }
+  }
+  async disposeAll() {
+    const disposals = Array.from(this.loadedInstances.values()).map(
+      (instance) => instance.dispose()
+    );
+    await Promise.all(disposals);
+    this.loadedInstances.clear();
+  }
+  async initialize() {
+    if (this.initialized) return;
+    this.initialized = true;
+    const builtins = [
+      json_default,
+      github_default,
+      jira_default,
+      linear_default,
+      markdown_default
+    ];
+    for (const factory of builtins) {
+      this.registerBuiltin(factory);
+    }
+  }
+};
+function getTrackerRegistry() {
+  return TrackerRegistry.getInstance();
+}
+
+export {
+  BaseTrackerPlugin,
+  JsonTrackerPlugin,
+  json_default,
+  GitHubTrackerPlugin,
+  github_default,
+  JiraTrackerPlugin,
+  jira_default,
+  LinearTrackerPlugin,
+  linear_default,
+  MarkdownTrackerPlugin,
+  markdown_default,
+  TrackerRegistry,
+  getTrackerRegistry
+};