panopticon-cli 0.4.32 → 0.5.0

package/dist/chunk-LYSBSZYV.js

@@ -1,1523 +0,0 @@
-import {
-  init_config_yaml,
-  loadConfig
-} from "./chunk-BBCUK6N2.js";
-import {
-  SETTINGS_FILE,
-  init_paths
-} from "./chunk-6HXKTOD7.js";
-import {
-  __esm,
-  init_esm_shims
-} from "./chunk-ZHC57RCV.js";
-
-// src/lib/settings.ts
-import { readFileSync, writeFileSync, existsSync } from "fs";
-function deepMerge(defaults, overrides) {
-  const result = { ...defaults };
-  for (const key of Object.keys(overrides)) {
-    const defaultVal = defaults[key];
-    const overrideVal = overrides[key];
-    if (overrideVal === void 0) continue;
-    if (typeof defaultVal === "object" && defaultVal !== null && !Array.isArray(defaultVal) && typeof overrideVal === "object" && overrideVal !== null && !Array.isArray(overrideVal)) {
-      result[key] = deepMerge(defaultVal, overrideVal);
-    } else {
-      result[key] = overrideVal;
-    }
-  }
-  return result;
-}
-function loadSettings() {
-  let settings;
-  if (!existsSync(SETTINGS_FILE)) {
-    settings = getDefaultSettings();
-  } else {
-    try {
-      const content = readFileSync(SETTINGS_FILE, "utf8");
-      const parsed = JSON.parse(content);
-      settings = deepMerge(DEFAULT_SETTINGS, parsed);
-    } catch (error) {
-      console.error("Warning: Failed to parse settings.json, using defaults");
-      settings = getDefaultSettings();
-    }
-  }
-  const envApiKeys = {};
-  if (process.env.OPENAI_API_KEY) envApiKeys.openai = process.env.OPENAI_API_KEY;
-  if (process.env.GOOGLE_API_KEY) envApiKeys.google = process.env.GOOGLE_API_KEY;
-  if (process.env.ZAI_API_KEY) envApiKeys.zai = process.env.ZAI_API_KEY;
-  if (process.env.KIMI_API_KEY) envApiKeys.kimi = process.env.KIMI_API_KEY;
-  settings.api_keys = {
-    ...envApiKeys,
-    ...settings.api_keys
-  };
-  return settings;
-}
-function saveSettings(settings) {
-  const content = JSON.stringify(settings, null, 2);
-  writeFileSync(SETTINGS_FILE, content, "utf8");
-}
-function validateSettings(settings) {
-  if (!settings.models) {
-    return "Missing models configuration";
-  }
-  if (!settings.models.specialists) {
-    return "Missing specialists configuration";
-  }
-  const specialists = settings.models.specialists;
-  if (!specialists.review_agent || !specialists.test_agent || !specialists.merge_agent) {
-    return "Missing specialist agent model configuration";
-  }
-  if (!settings.models.planning_agent) {
-    return "Missing planning_agent configuration";
-  }
-  if (!settings.models.complexity) {
-    return "Missing complexity configuration";
-  }
-  const complexity = settings.models.complexity;
-  const requiredLevels = ["trivial", "simple", "medium", "complex", "expert"];
-  for (const level of requiredLevels) {
-    if (!complexity[level]) {
-      return `Missing complexity level: ${level}`;
-    }
-  }
-  if (!settings.api_keys) {
-    return "Missing api_keys configuration";
-  }
-  return null;
-}
-function getDefaultSettings() {
-  return JSON.parse(JSON.stringify(DEFAULT_SETTINGS));
-}
-function getAvailableModels(settings) {
-  const anthropicModels = [
-    "claude-opus-4-6",
-    "claude-sonnet-4-5",
-    "claude-haiku-4-5"
-  ];
-  const openaiModels = settings.api_keys.openai ? ["gpt-5.2-codex", "o3-deep-research", "gpt-4o", "gpt-4o-mini"] : [];
-  const googleModels = settings.api_keys.google ? ["gemini-3-pro-preview", "gemini-3-flash-preview"] : [];
-  const zaiModels = settings.api_keys.zai ? ["glm-4.7", "glm-4.7-flash"] : [];
-  const kimiModels = settings.api_keys.kimi ? ["kimi-k2", "kimi-k2.5"] : [];
-  return {
-    anthropic: anthropicModels,
-    openai: openaiModels,
-    google: googleModels,
-    zai: zaiModels,
-    kimi: kimiModels
-  };
-}
-function isAnthropicModel(modelId) {
-  return modelId.startsWith("claude-");
-}
-function getClaudeModelFlag(modelId) {
-  const modelMap = {
-    "claude-opus-4-6": "opus",
-    "claude-sonnet-4-5": "sonnet",
-    "claude-haiku-4-5": "haiku"
-  };
-  return modelMap[modelId] || "sonnet";
-}
-function getAgentCommand(modelId) {
-  if (isAnthropicModel(modelId)) {
-    return {
-      command: "claude",
-      args: ["--model", getClaudeModelFlag(modelId)]
-    };
-  }
-  return {
-    command: "claude-code-router",
-    args: []
-  };
-}
-var DEFAULT_SETTINGS;
-var init_settings = __esm({
-  "src/lib/settings.ts"() {
-    "use strict";
-    init_esm_shims();
-    init_paths();
-    DEFAULT_SETTINGS = {
-      models: {
-        specialists: {
-          review_agent: "claude-opus-4-6",
-          test_agent: "claude-sonnet-4-5",
-          merge_agent: "claude-sonnet-4-5"
-        },
-        planning_agent: "claude-opus-4-6",
-        status_review: "claude-opus-4-6",
-        complexity: {
-          trivial: "claude-haiku-4-5",
-          simple: "claude-haiku-4-5",
-          medium: "kimi-k2.5",
-          complex: "kimi-k2.5",
-          expert: "claude-opus-4-6"
-        }
-      },
-      api_keys: {}
-    };
-  }
-});
-
-// src/lib/providers.ts
-function getProviderForModel(modelId) {
-  if (["claude-opus-4-6", "claude-sonnet-4-5", "claude-haiku-4-5"].includes(modelId)) {
-    return PROVIDERS.anthropic;
-  }
-  if (["gpt-5.2-codex", "o3-deep-research", "gpt-4o", "gpt-4o-mini"].includes(modelId)) {
-    return PROVIDERS.openai;
-  }
-  if (["gemini-3-pro-preview", "gemini-3-flash-preview"].includes(modelId)) {
-    return PROVIDERS.google;
-  }
-  if (["glm-4.7", "glm-4.7-flash"].includes(modelId)) {
-    return PROVIDERS.zai;
-  }
-  if (["kimi-k2", "kimi-k2.5"].includes(modelId)) {
-    return PROVIDERS.kimi;
-  }
-  return PROVIDERS.anthropic;
-}
-function requiresRouter(provider) {
-  return PROVIDERS[provider].compatibility === "router";
-}
-function getRouterProviders() {
-  return Object.values(PROVIDERS).filter((p) => p.compatibility === "router");
-}
-function getDirectProviders() {
-  return Object.values(PROVIDERS).filter((p) => p.compatibility === "direct");
-}
-function needsRouter(apiKeys) {
-  return !!(apiKeys.openai || apiKeys.google);
-}
-function getProviderEnv(provider, apiKey) {
-  if (provider.compatibility === "direct") {
-    const env = {};
-    if (provider.baseUrl) {
-      env.ANTHROPIC_BASE_URL = provider.baseUrl;
-    }
-    if (provider.name !== "anthropic") {
-      env.ANTHROPIC_AUTH_TOKEN = apiKey;
-    }
-    if (provider.name === "zai") {
-      env.API_TIMEOUT_MS = "300000";
-    }
-    return env;
-  } else {
-    return {
-      ANTHROPIC_BASE_URL: "http://localhost:3456",
-      ANTHROPIC_AUTH_TOKEN: "router-managed"
-    };
-  }
-}
-var PROVIDERS;
-var init_providers = __esm({
-  "src/lib/providers.ts"() {
-    "use strict";
-    init_esm_shims();
-    PROVIDERS = {
-      anthropic: {
-        name: "anthropic",
-        displayName: "Anthropic",
-        compatibility: "direct",
-        models: ["claude-opus-4-6", "claude-sonnet-4-5", "claude-haiku-4-5"],
-        tested: true,
-        description: "Native Claude API"
-      },
-      kimi: {
-        name: "kimi",
-        displayName: "Kimi (Moonshot AI)",
-        compatibility: "direct",
-        baseUrl: "https://api.kimi.com/coding/",
-        models: [],
-        // Kimi uses same model names as Anthropic
-        tested: true,
-        description: "Anthropic-compatible API, tested 2026-01-28"
-      },
-      zai: {
-        name: "zai",
-        displayName: "Z.AI (GLM)",
-        compatibility: "direct",
-        baseUrl: "https://api.z.ai/api/anthropic",
-        models: ["glm-4.7", "glm-4.7-flash"],
-        tested: true,
-        description: "Anthropic-compatible API, tested 2026-01-28"
-      },
-      openai: {
-        name: "openai",
-        displayName: "OpenAI",
-        compatibility: "router",
-        models: ["gpt-5.2-codex", "o3-deep-research", "gpt-4o", "gpt-4o-mini"],
-        tested: false,
-        description: "Requires claude-code-router for API translation"
-      },
-      google: {
-        name: "google",
-        displayName: "Google (Gemini)",
-        compatibility: "router",
-        models: ["gemini-3-pro-preview", "gemini-3-flash-preview"],
-        tested: false,
-        description: "Requires claude-code-router for API translation"
-      }
-    };
-  }
-});
-
-// src/lib/tracker/interface.ts
-var NotImplementedError, IssueNotFoundError, TrackerAuthError;
-var init_interface = __esm({
-  "src/lib/tracker/interface.ts"() {
-    "use strict";
-    init_esm_shims();
-    NotImplementedError = class extends Error {
-      constructor(feature) {
-        super(`Not implemented: ${feature}`);
-        this.name = "NotImplementedError";
-      }
-    };
-    IssueNotFoundError = class extends Error {
-      constructor(id, tracker) {
-        super(`Issue not found: ${id} (tracker: ${tracker})`);
-        this.name = "IssueNotFoundError";
-      }
-    };
-    TrackerAuthError = class extends Error {
-      constructor(tracker, message) {
-        super(`Authentication failed for ${tracker}: ${message}`);
-        this.name = "TrackerAuthError";
-      }
-    };
-  }
-});
-
-// src/lib/tracker/linear.ts
-import { LinearClient } from "@linear/sdk";
-var STATE_MAP, LinearTracker;
-var init_linear = __esm({
-  "src/lib/tracker/linear.ts"() {
-    "use strict";
-    init_esm_shims();
-    init_interface();
-    STATE_MAP = {
-      backlog: "open",
-      unstarted: "open",
-      started: "in_progress",
-      completed: "closed",
-      canceled: "closed"
-    };
-    LinearTracker = class {
-      name = "linear";
-      client;
-      defaultTeam;
-      constructor(apiKey, options) {
-        if (!apiKey) {
-          throw new TrackerAuthError("linear", "API key is required");
-        }
-        this.client = new LinearClient({ apiKey });
-        this.defaultTeam = options?.team;
-      }
-      async listIssues(filters) {
-        const team = filters?.team ?? this.defaultTeam;
-        const result = await this.client.issues({
-          first: filters?.limit ?? 50,
-          filter: {
-            team: team ? { key: { eq: team } } : void 0,
-            state: filters?.state ? { type: { eq: this.reverseMapState(filters.state) } } : filters?.includeClosed ? void 0 : { type: { neq: "completed" } },
-            labels: filters?.labels?.length ? { name: { in: filters.labels } } : void 0,
-            assignee: filters?.assignee ? { name: { containsIgnoreCase: filters.assignee } } : void 0
-          }
-        });
-        const issues = [];
-        for (const node of result.nodes) {
-          issues.push(await this.normalizeIssue(node));
-        }
-        return issues;
-      }
-      async getIssue(id) {
-        try {
-          const isUuid = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(id);
-          if (isUuid) {
-            const issue = await this.client.issue(id);
-            if (issue) {
-              return this.normalizeIssue(issue);
-            }
-          } else {
-            const match = id.match(/^([A-Z]+)-(\d+)$/i);
-            if (match) {
-              const [, teamKey, number] = match;
-              const results = await this.client.searchIssues(id, { first: 1 });
-              if (results.nodes.length > 0) {
-                return this.normalizeIssue(results.nodes[0]);
-              }
-            }
-          }
-          throw new IssueNotFoundError(id, "linear");
-        } catch (error) {
-          if (error instanceof IssueNotFoundError) throw error;
-          throw new IssueNotFoundError(id, "linear");
-        }
-      }
-      async updateIssue(id, update) {
-        const issue = await this.getIssue(id);
-        const updatePayload = {};
-        if (update.title !== void 0) {
-          updatePayload.title = update.title;
-        }
-        if (update.description !== void 0) {
-          updatePayload.description = update.description;
-        }
-        if (update.priority !== void 0) {
-          updatePayload.priority = update.priority;
-        }
-        if (update.dueDate !== void 0) {
-          updatePayload.dueDate = update.dueDate;
-        }
-        if (update.state !== void 0) {
-          await this.transitionIssue(id, update.state);
-        }
-        if (update.labels !== void 0) {
-        }
-        if (Object.keys(updatePayload).length > 0) {
-          await this.client.updateIssue(issue.id, updatePayload);
-        }
-        return this.getIssue(id);
-      }
-      async createIssue(newIssue) {
-        const team = newIssue.team ?? this.defaultTeam;
-        if (!team) {
-          throw new Error("Team is required to create an issue");
-        }
-        const teams = await this.client.teams({
-          filter: { key: { eq: team } }
-        });
-        if (teams.nodes.length === 0) {
-          throw new Error(`Team not found: ${team}`);
-        }
-        const teamId = teams.nodes[0].id;
-        const result = await this.client.createIssue({
-          teamId,
-          title: newIssue.title,
-          description: newIssue.description,
-          priority: newIssue.priority,
-          dueDate: newIssue.dueDate
-        });
-        const created = await result.issue;
-        if (!created) {
-          throw new Error("Failed to create issue");
-        }
-        return this.normalizeIssue(created);
-      }
-      async getComments(issueId) {
-        const issue = await this.client.issue(issueId);
-        const comments = await issue.comments();
-        return comments.nodes.map((c) => ({
-          id: c.id,
-          issueId,
-          body: c.body,
-          author: c.user?.then((u) => u?.name ?? "Unknown"),
-          // Simplified
-          createdAt: c.createdAt.toISOString(),
-          updatedAt: c.updatedAt.toISOString()
-        }));
-      }
-      async addComment(issueId, body) {
-        const result = await this.client.createComment({
-          issueId,
-          body
-        });
-        const comment = await result.comment;
-        if (!comment) {
-          throw new Error("Failed to create comment");
-        }
-        return {
-          id: comment.id,
-          issueId,
-          body: comment.body,
-          author: "Panopticon",
-          // Simplified
-          createdAt: comment.createdAt.toISOString(),
-          updatedAt: comment.updatedAt.toISOString()
-        };
-      }
-      async transitionIssue(id, state) {
-        let linearIssue;
-        const isUuid = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(id);
-        if (isUuid) {
-          linearIssue = await this.client.issue(id);
-        } else {
-          const results = await this.client.searchIssues(id, { first: 1 });
-          if (results.nodes.length > 0) {
-            linearIssue = results.nodes[0];
-          } else {
-            throw new IssueNotFoundError(id, "linear");
-          }
-        }
-        const team = await linearIssue.team;
-        if (!team) {
-          throw new Error("Could not determine issue team");
-        }
-        const states = await team.states();
-        const targetStateType = this.reverseMapState(state);
-        const matchingStates = states.nodes.filter((s) => s.type === targetStateType).sort((a, b) => (a.position ?? 0) - (b.position ?? 0));
-        const targetState = matchingStates[0];
-        if (!targetState) {
-          throw new Error(`No state found matching type: ${targetStateType}`);
-        }
-        await this.client.updateIssue(linearIssue.id, {
-          stateId: targetState.id
-        });
-      }
-      async linkPR(issueId, prUrl) {
-        const issue = await this.getIssue(issueId);
-        await this.client.createAttachment({
-          issueId: issue.id,
-          title: "Pull Request",
-          url: prUrl
-        });
-      }
-      async normalizeIssue(linearIssue) {
-        const state = await linearIssue.state;
-        const assignee = await linearIssue.assignee;
-        const labels = await linearIssue.labels();
-        let dueDate;
-        if (linearIssue.dueDate) {
-          dueDate = linearIssue.dueDate instanceof Date ? linearIssue.dueDate.toISOString() : String(linearIssue.dueDate);
-        }
-        return {
-          id: linearIssue.id,
-          ref: linearIssue.identifier,
-          title: linearIssue.title,
-          description: linearIssue.description ?? "",
-          state: this.mapState(state?.type ?? "backlog"),
-          labels: labels?.nodes?.map((l) => l.name) ?? [],
-          assignee: assignee?.name,
-          url: linearIssue.url,
-          tracker: "linear",
-          priority: linearIssue.priority,
-          dueDate,
-          createdAt: linearIssue.createdAt instanceof Date ? linearIssue.createdAt.toISOString() : String(linearIssue.createdAt),
-          updatedAt: linearIssue.updatedAt instanceof Date ? linearIssue.updatedAt.toISOString() : String(linearIssue.updatedAt)
-        };
-      }
-      mapState(linearState) {
-        return STATE_MAP[linearState] ?? "open";
-      }
-      reverseMapState(state) {
-        switch (state) {
-          case "open":
-            return "unstarted";
-          case "in_progress":
-            return "started";
-          case "closed":
-            return "completed";
-          default:
-            return "unstarted";
-        }
-      }
-    };
-  }
-});
-
-// src/lib/tracker/github.ts
-import { Octokit } from "@octokit/rest";
-var GitHubTracker;
-var init_github = __esm({
-  "src/lib/tracker/github.ts"() {
-    "use strict";
-    init_esm_shims();
-    init_interface();
-    GitHubTracker = class {
-      name = "github";
-      octokit;
-      owner;
-      repo;
-      constructor(token, owner, repo) {
-        if (!token) {
-          throw new TrackerAuthError("github", "Token is required");
-        }
-        if (!owner || !repo) {
-          throw new Error("GitHub owner and repo are required");
-        }
-        this.octokit = new Octokit({ auth: token });
-        this.owner = owner;
-        this.repo = repo;
-      }
-      async listIssues(filters) {
-        const state = this.mapStateToGitHub(filters?.state);
-        const response = await this.octokit.issues.listForRepo({
-          owner: this.owner,
-          repo: this.repo,
-          state: filters?.includeClosed ? "all" : state,
-          labels: filters?.labels?.join(",") || void 0,
-          assignee: filters?.assignee || void 0,
-          per_page: filters?.limit ?? 50
-        });
-        const issues = response.data.filter((item) => !item.pull_request);
-        return issues.map((issue) => this.normalizeIssue(issue));
-      }
-      async getIssue(id) {
-        try {
-          const issueNumber = parseInt(id.replace(/^#/, ""), 10);
-          if (isNaN(issueNumber)) {
-            throw new IssueNotFoundError(id, "github");
-          }
-          const { data: issue } = await this.octokit.issues.get({
-            owner: this.owner,
-            repo: this.repo,
-            issue_number: issueNumber
-          });
-          return this.normalizeIssue(issue);
-        } catch (error) {
-          if (error?.status === 404) {
-            throw new IssueNotFoundError(id, "github");
-          }
-          throw error;
-        }
-      }
-      async updateIssue(id, update) {
-        const issueNumber = parseInt(id.replace(/^#/, ""), 10);
-        const updatePayload = {};
-        if (update.title !== void 0) {
-          updatePayload.title = update.title;
-        }
-        if (update.description !== void 0) {
-          updatePayload.body = update.description;
-        }
-        if (update.state !== void 0) {
-          updatePayload.state = update.state === "closed" ? "closed" : "open";
-        }
-        if (update.labels !== void 0) {
-          updatePayload.labels = update.labels;
-        }
-        if (update.assignee !== void 0) {
-          updatePayload.assignees = update.assignee ? [update.assignee] : [];
-        }
-        await this.octokit.issues.update({
-          owner: this.owner,
-          repo: this.repo,
-          issue_number: issueNumber,
-          ...updatePayload
-        });
-        return this.getIssue(id);
-      }
-      async createIssue(newIssue) {
-        const { data: issue } = await this.octokit.issues.create({
-          owner: this.owner,
-          repo: this.repo,
-          title: newIssue.title,
-          body: newIssue.description,
-          labels: newIssue.labels,
-          assignees: newIssue.assignee ? [newIssue.assignee] : void 0
-        });
-        return this.normalizeIssue(issue);
-      }
-      async getComments(issueId) {
-        const issueNumber = parseInt(issueId.replace(/^#/, ""), 10);
-        const { data: comments } = await this.octokit.issues.listComments({
-          owner: this.owner,
-          repo: this.repo,
-          issue_number: issueNumber
-        });
-        return comments.map((c) => ({
-          id: String(c.id),
-          issueId,
-          body: c.body ?? "",
-          author: c.user?.login ?? "Unknown",
-          createdAt: c.created_at,
-          updatedAt: c.updated_at
-        }));
-      }
-      async addComment(issueId, body) {
-        const issueNumber = parseInt(issueId.replace(/^#/, ""), 10);
-        const { data: comment } = await this.octokit.issues.createComment({
-          owner: this.owner,
-          repo: this.repo,
-          issue_number: issueNumber,
-          body
-        });
-        return {
-          id: String(comment.id),
-          issueId,
-          body: comment.body ?? "",
-          author: comment.user?.login ?? "Unknown",
-          createdAt: comment.created_at,
-          updatedAt: comment.updated_at
-        };
-      }
-      async transitionIssue(id, state) {
-        await this.updateIssue(id, { state });
-      }
-      async linkPR(issueId, prUrl) {
-        await this.addComment(
-          issueId,
-          `Linked Pull Request: ${prUrl}`
-        );
-      }
-      normalizeIssue(ghIssue) {
-        return {
-          id: String(ghIssue.id),
-          ref: `#${ghIssue.number}`,
-          title: ghIssue.title,
-          description: ghIssue.body ?? "",
-          state: this.mapStateFromGitHub(ghIssue.state),
-          labels: ghIssue.labels.map(
-            (l) => typeof l === "string" ? l : l.name
-          ),
-          assignee: ghIssue.assignee?.login,
-          url: ghIssue.html_url,
-          tracker: "github",
-          priority: void 0,
-          // GitHub doesn't have priority
-          dueDate: void 0,
-          // GitHub doesn't have due dates on issues
-          createdAt: ghIssue.created_at,
-          updatedAt: ghIssue.updated_at
-        };
-      }
-      mapStateFromGitHub(ghState) {
-        return ghState === "closed" ? "closed" : "open";
-      }
-      mapStateToGitHub(state) {
-        if (!state) return "open";
-        if (state === "closed") return "closed";
-        return "open";
-      }
-    };
-  }
-});
-
-// src/lib/tracker/gitlab.ts
-var GitLabTracker;
-var init_gitlab = __esm({
-  "src/lib/tracker/gitlab.ts"() {
-    "use strict";
-    init_esm_shims();
-    init_interface();
-    GitLabTracker = class {
-      constructor(token, projectId) {
-        this.token = token;
-        this.projectId = projectId;
-      }
-      name = "gitlab";
-      async listIssues(_filters) {
-        throw new NotImplementedError(
-          "GitLab tracker is not yet implemented. Coming soon!"
-        );
-      }
-      async getIssue(_id) {
-        throw new NotImplementedError(
-          "GitLab tracker is not yet implemented. Coming soon!"
-        );
-      }
-      async updateIssue(_id, _update) {
-        throw new NotImplementedError(
-          "GitLab tracker is not yet implemented. Coming soon!"
-        );
-      }
-      async createIssue(_issue) {
-        throw new NotImplementedError(
-          "GitLab tracker is not yet implemented. Coming soon!"
-        );
-      }
-      async getComments(_issueId) {
-        throw new NotImplementedError(
-          "GitLab tracker is not yet implemented. Coming soon!"
-        );
-      }
-      async addComment(_issueId, _body) {
-        throw new NotImplementedError(
-          "GitLab tracker is not yet implemented. Coming soon!"
-        );
-      }
-      async transitionIssue(_id, _state) {
-        throw new NotImplementedError(
-          "GitLab tracker is not yet implemented. Coming soon!"
-        );
-      }
-      async linkPR(_issueId, _prUrl) {
-        throw new NotImplementedError(
-          "GitLab tracker is not yet implemented. Coming soon!"
-        );
-      }
-    };
-  }
-});
-
-// src/lib/tracker/rally-api.ts
-var RallyRestApi;
-var init_rally_api = __esm({
-  "src/lib/tracker/rally-api.ts"() {
-    "use strict";
-    init_esm_shims();
-    RallyRestApi = class {
-      apiKey;
-      server;
-      customHeaders;
-      constructor(config) {
-        this.apiKey = config.apiKey;
-        this.server = config.server || "https://rally1.rallydev.com";
-        this.customHeaders = config.requestOptions?.headers || {};
-      }
-      /**
-       * Query Rally artifacts
-       */
-      async query(config) {
-        const params = new URLSearchParams();
-        if (config.query) {
-          params.set("query", config.query);
-        }
-        if (config.fetch && config.fetch.length > 0) {
-          params.set("fetch", config.fetch.join(","));
-        }
-        if (config.limit !== void 0) {
-          params.set("pagesize", String(config.limit));
-        }
-        if (config.workspace) {
-          params.set("workspace", config.workspace);
-        }
-        if (config.project) {
-          params.set("project", config.project);
-          if (config.projectScopeDown) {
-            params.set("projectScopeDown", "true");
-          }
-        }
-        if (config.order) {
-          params.set("order", config.order);
-        }
-        const url = `${this.server}/slm/webservice/v2.0/${config.type}?${params.toString()}`;
-        const response = await fetch(url, {
-          method: "GET",
-          headers: {
-            "ZSESSIONID": this.apiKey,
-            "Content-Type": "application/json",
-            ...this.customHeaders
-          }
-        });
-        if (!response.ok) {
-          if (response.status === 401) {
-            throw new Error("Unauthorized: Invalid API key or insufficient permissions");
-          }
-          throw new Error(`Rally API query failed: ${response.status} ${response.statusText}`);
-        }
-        const result = await response.json();
-        if (result.QueryResult.Errors && result.QueryResult.Errors.length > 0) {
-          const errorDetail = result.QueryResult.Errors.join(", ");
-          const queryDetail = config.query ? ` (Query: ${config.query})` : "";
-          if (process.env.DEBUG?.includes("rally")) {
-            console.error("[Rally WSAPI] Query failed:", { query: config.query, errors: result.QueryResult.Errors });
-          }
-          throw new Error(`Rally API query failed: ${errorDetail}${queryDetail}`);
-        }
-        return result;
-      }
-      /**
-       * Create a Rally object
-       */
-      async create(config) {
-        const url = `${this.server}/slm/webservice/v2.0/${config.type}/create`;
-        const body = {
-          [config.type]: config.data
-        };
-        const params = new URLSearchParams();
-        if (config.fetch && config.fetch.length > 0) {
-          params.set("fetch", config.fetch.join(","));
-        }
-        const finalUrl = params.toString() ? `${url}?${params.toString()}` : url;
-        const response = await fetch(finalUrl, {
-          method: "POST",
-          headers: {
-            "ZSESSIONID": this.apiKey,
-            "Content-Type": "application/json",
-            ...this.customHeaders
-          },
-          body: JSON.stringify(body)
-        });
-        if (!response.ok) {
-          throw new Error(`Rally API create failed: ${response.status} ${response.statusText}`);
-        }
-        const result = await response.json();
-        if (result.CreateResult.Errors && result.CreateResult.Errors.length > 0) {
-          throw new Error(`Rally API create failed: ${result.CreateResult.Errors.join(", ")}`);
-        }
-        return result;
-      }
-      /**
-       * Update a Rally object
-       */
-      async update(config) {
-        const objectId = config.ref.split("/").pop();
-        const url = `${this.server}/slm/webservice/v2.0/${config.type}/${objectId}`;
-        const body = {
-          [config.type]: config.data
-        };
-        const params = new URLSearchParams();
-        if (config.fetch && config.fetch.length > 0) {
-          params.set("fetch", config.fetch.join(","));
-        }
-        const finalUrl = params.toString() ? `${url}?${params.toString()}` : url;
-        const response = await fetch(finalUrl, {
-          method: "POST",
-          headers: {
-            "ZSESSIONID": this.apiKey,
-            "Content-Type": "application/json",
-            ...this.customHeaders
-          },
-          body: JSON.stringify(body)
-        });
-        if (!response.ok) {
-          throw new Error(`Rally API update failed: ${response.status} ${response.statusText}`);
-        }
-        const result = await response.json();
-        if (result.OperationResult.Errors && result.OperationResult.Errors.length > 0) {
-          throw new Error(`Rally API update failed: ${result.OperationResult.Errors.join(", ")}`);
-        }
-        return result;
-      }
-    };
-  }
-});
-
-// src/lib/tracker/rally.ts
-var STATE_MAP2, QUERYABLE_TYPES, FETCH_FIELDS, PRIORITY_MAP, REVERSE_PRIORITY_MAP, RallyTracker;
-var init_rally = __esm({
-  "src/lib/tracker/rally.ts"() {
-    "use strict";
-    init_esm_shims();
-    init_rally_api();
-    init_interface();
-    STATE_MAP2 = {
-      // User Stories (ScheduleState)
-      "New": "open",
-      "Idea": "open",
-      "Defined": "open",
-      "In-Progress": "in_progress",
-      "Completed": "closed",
-      "Accepted": "closed",
-      // Defects (State)
-      "Submitted": "open",
-      "Open": "in_progress",
-      // "Open" defects are actively being worked
-      "Fixed": "closed",
-      "Closed": "closed",
-      // Features / PortfolioItems (State)
-      "Discovering": "open",
-      "Developing": "in_progress",
-      "Done": "closed"
-    };
-    QUERYABLE_TYPES = [
-      { type: "hierarchicalrequirement", stateField: "ScheduleState", closedStates: ["Completed", "Accepted"] },
-      { type: "defect", stateField: "State", closedStates: ["Closed"] },
-      { type: "task", stateField: "State", closedStates: ["Completed"] },
-      { type: "portfolioitem/feature", stateField: "State", closedStates: ["Done"] }
-    ];
-    FETCH_FIELDS = [
-      "ObjectID",
-      "FormattedID",
-      "Name",
-      "Description",
-      "ScheduleState",
-      "State",
-      "Tags",
-      "Owner",
-      "Priority",
-      "DueDate",
-      "CreationDate",
-      "LastUpdateDate",
-      "Parent",
-      "PortfolioItem",
-      "_type"
-    ];
-    PRIORITY_MAP = {
-      "Resolve Immediately": 0,
-      High: 1,
-      Normal: 2,
-      Low: 3
-    };
-    REVERSE_PRIORITY_MAP = {
-      0: "Resolve Immediately",
-      1: "High",
-      2: "Normal",
-      3: "Low",
-      4: "Low"
-    };
-    RallyTracker = class {
-      name = "rally";
-      restApi;
-      workspace;
-      project;
-      constructor(config) {
-        if (!config.apiKey) {
-          throw new TrackerAuthError("rally", "API key is required");
-        }
-        this.restApi = new RallyRestApi({
-          apiKey: config.apiKey,
-          server: config.server || "https://rally1.rallydev.com",
-          requestOptions: {
-            headers: {
-              "X-RallyIntegrationType": "Panopticon",
-              "X-RallyIntegrationName": "Panopticon CLI",
-              "X-RallyIntegrationVendor": "Mind Your Now",
-              "X-RallyIntegrationVersion": "0.2.0"
-            }
-          }
-        });
-        this.workspace = config.workspace;
-        this.project = config.project;
-      }
-      /**
-       * List issues by querying each artifact type separately and merging results.
-       *
-       * Rally WSAPI cannot apply ScheduleState filters across the generic Artifact
-       * endpoint because not all subtypes have that field. We query each type with
-       * its own state field, then merge and sort. (PAN-168)
-       */
-      async listIssues(filters) {
-        if (process.env.DEBUG?.includes("rally")) {
-          console.debug("[Rally] Query filters:", JSON.stringify(filters));
-        }
-        const limit = filters?.limit ?? 50;
-        let projectObjectId;
-        if (this.project) {
-          const match = this.project.match(/\/project\/(\d+)/);
-          if (match) projectObjectId = match[1];
-        }
-        const queries = QUERYABLE_TYPES.map(async (artifactType) => {
-          const queryString = this.buildQueryStringForType(filters, artifactType, projectObjectId);
-          if (process.env.DEBUG?.includes("rally")) {
-            console.debug(`[Rally] ${artifactType.type} query:`, queryString);
-          }
-          const query = {
-            type: artifactType.type,
-            fetch: FETCH_FIELDS,
-            limit,
-            query: queryString
-          };
-          if (this.workspace) {
-            query.workspace = this.workspace;
-          }
-          if (this.project) {
-            query.project = this.project;
-            query.projectScopeDown = true;
-          }
-          try {
-            const result = await this.queryRally(query);
-            return result.Results.map((artifact) => this.normalizeIssue(artifact));
-          } catch (error) {
-            if (error.message?.includes("Unauthorized") || error.message?.includes("401")) {
-              throw new TrackerAuthError("rally", "Invalid API key or insufficient permissions");
-            }
-            if (process.env.DEBUG?.includes("rally")) {
-              console.debug(`[Rally] Failed to query ${artifactType.type}:`, error.message);
-            }
-            return [];
-          }
-        });
-        const results = await Promise.all(queries);
-        const allIssues = results.flat();
-        allIssues.sort(
-          (a, b) => new Date(b.updatedAt).getTime() - new Date(a.updatedAt).getTime()
-        );
-        return allIssues.slice(0, limit);
-      }
-      async getIssue(id) {
-        try {
-          const query = {
-            type: "artifact",
-            fetch: [
-              "FormattedID",
-              "Name",
-              "Description",
-              "ScheduleState",
-              "State",
-              "Tags",
-              "Owner",
-              "Priority",
-              "DueDate",
-              "CreationDate",
-              "LastUpdateDate",
-              "Parent",
-              "_type"
-            ],
-            query: `(FormattedID = "${id}")`
-          };
-          if (this.workspace) {
-            query.workspace = this.workspace;
-          }
-          const result = await this.queryRally(query);
-          if (!result.Results || result.Results.length === 0) {
-            throw new IssueNotFoundError(id, "rally");
-          }
-          return this.normalizeIssue(result.Results[0]);
-        } catch (error) {
-          if (error instanceof IssueNotFoundError) throw error;
-          throw new IssueNotFoundError(id, "rally");
-        }
-      }
-      async updateIssue(id, update) {
-        const issue = await this.getIssue(id);
-        const query = {
-          type: "artifact",
-          fetch: ["ObjectID", "_ref", "_type"],
-          query: `(FormattedID = "${id}")`
-        };
-        if (this.workspace) {
-          query.workspace = this.workspace;
-        }
-        const result = await this.queryRally(query);
-        if (!result.Results || result.Results.length === 0) {
-          throw new IssueNotFoundError(id, "rally");
-        }
-        const artifact = result.Results[0];
-        const updatePayload = {};
-        if (update.title !== void 0) {
-          updatePayload.Name = update.title;
-        }
-        if (update.description !== void 0) {
-          updatePayload.Description = update.description;
-        }
-        if (update.state !== void 0) {
-          const artifactType = (artifact._type || "").toLowerCase();
-          const kind = artifactType.startsWith("portfolioitem") ? "feature" : artifactType === "defect" ? "defect" : "story";
-          const rallyState = this.reverseMapState(update.state, kind);
-          if (kind === "story") {
-            updatePayload.ScheduleState = rallyState;
-          } else {
-            updatePayload.State = rallyState;
-          }
-        }
-        if (update.priority !== void 0) {
-          updatePayload.Priority = REVERSE_PRIORITY_MAP[update.priority] || "Normal";
-        }
-        if (update.dueDate !== void 0) {
-          updatePayload.DueDate = update.dueDate;
-        }
-        if (Object.keys(updatePayload).length > 0) {
-          await this.updateRally(artifact._type.toLowerCase(), artifact._ref, updatePayload);
-        }
-        return this.getIssue(id);
-      }
-      async createIssue(newIssue) {
-        if (!this.project && !newIssue.team) {
-          throw new Error("Project is required to create an issue. Set it in config or provide team field.");
-        }
-        const project = newIssue.team || this.project;
-        const createPayload = {
-          Name: newIssue.title,
-          Description: newIssue.description || "",
-          Project: project
-        };
-        if (newIssue.priority !== void 0) {
-          createPayload.Priority = REVERSE_PRIORITY_MAP[newIssue.priority] || "Normal";
-        }
-        if (newIssue.dueDate) {
-          createPayload.DueDate = newIssue.dueDate;
-        }
-        if (this.workspace) {
-          createPayload.Workspace = this.workspace;
-        }
-        const result = await this.createRally("hierarchicalrequirement", createPayload);
-        return this.getIssue(result.Object.FormattedID);
-      }
-      async getComments(issueId) {
-        const issue = await this.getIssue(issueId);
-        const query = {
-          type: "artifact",
-          fetch: ["ObjectID", "_ref", "Discussion"],
-          query: `(FormattedID = "${issueId}")`
-        };
-        if (this.workspace) {
-          query.workspace = this.workspace;
-        }
-        const result = await this.queryRally(query);
-        if (!result.Results || result.Results.length === 0) {
-          return [];
-        }
-        const artifact = result.Results[0];
-        if (!artifact.Discussion) {
-          return [];
-        }
-        const postsQuery = {
-          type: "conversationpost",
-          fetch: ["ObjectID", "Text", "User", "CreationDate", "PostNumber"],
-          query: `(Discussion = "${artifact.Discussion._ref}")`,
-          order: "PostNumber"
-        };
-        const postsResult = await this.queryRally(postsQuery);
-        return (postsResult.Results || []).map((post) => ({
-          id: post.ObjectID,
-          issueId,
-          body: post.Text || "",
-          author: post.User?._refObjectName || "Unknown",
-          createdAt: post.CreationDate,
-          updatedAt: post.CreationDate
-          // Rally doesn't track comment updates separately
-        }));
-      }
-      async addComment(issueId, body) {
-        const query = {
-          type: "artifact",
-          fetch: ["ObjectID", "_ref", "Discussion"],
-          query: `(FormattedID = "${issueId}")`
-        };
-        if (this.workspace) {
-          query.workspace = this.workspace;
-        }
-        const result = await this.queryRally(query);
-        if (!result.Results || result.Results.length === 0) {
-          throw new IssueNotFoundError(issueId, "rally");
-        }
-        const artifact = result.Results[0];
-        let discussionRef = artifact.Discussion?._ref;
-        if (!discussionRef) {
-          const discussionResult = await this.createRally("conversationpost", {
-            Artifact: artifact._ref,
-            Text: body
-          });
-          return {
-            id: discussionResult.Object.ObjectID,
-            issueId,
-            body,
-            author: "Panopticon",
-            createdAt: (/* @__PURE__ */ new Date()).toISOString(),
-            updatedAt: (/* @__PURE__ */ new Date()).toISOString()
-          };
-        }
-        const postResult = await this.createRally("conversationpost", {
-          Artifact: artifact._ref,
-          Text: body
-        });
-        return {
-          id: postResult.Object.ObjectID,
-          issueId,
-          body,
-          author: "Panopticon",
-          createdAt: (/* @__PURE__ */ new Date()).toISOString(),
-          updatedAt: (/* @__PURE__ */ new Date()).toISOString()
-        };
-      }
-      async transitionIssue(id, state) {
-        await this.updateIssue(id, { state });
-      }
-      async linkPR(issueId, prUrl) {
-        await this.addComment(issueId, `Linked Pull Request: ${prUrl}`);
-      }
-      // Private helper methods
-      /**
-       * Build a Rally WSAPI query string for a specific artifact type.
-       *
-       * Each artifact type has its own state field:
-       *   - HierarchicalRequirement: ScheduleState (Defined, In-Progress, Completed, Accepted)
-       *   - Defect: State (Submitted, Open, Fixed, Closed)
-       *   - Task: State (Defined, In-Progress, Completed)
-       *
-       * Rally WSAPI v2.0 requires binary-nested AND/OR with outer parentheses.
-       * (PAN-166, PAN-168)
-       */
-      buildQueryStringForType(filters, artifactType, projectObjectId) {
-        const conditions = [];
-        if (projectObjectId) {
-          conditions.push(`(Project.ObjectID = "${projectObjectId}")`);
-        }
-        if (filters?.state && !filters.includeClosed) {
-          const kind = artifactType.type.startsWith("portfolioitem") ? "feature" : artifactType.type === "defect" ? "defect" : "story";
-          const rallyState = this.reverseMapState(filters.state, kind);
-          conditions.push(`(${artifactType.stateField} = "${rallyState}")`);
-        }
-        if (!filters?.includeClosed) {
-          const closedConditions = artifactType.closedStates.map(
-            (state) => `(${artifactType.stateField} != "${state}")`
-          );
-          const closedExpr = closedConditions.reduce(
-            (acc, cond) => acc ? `(${acc} AND ${cond})` : cond,
-            ""
-          );
-          conditions.push(closedExpr);
-        }
-        if (filters?.assignee) {
-          conditions.push(`(Owner.Name contains "${filters.assignee}")`);
-        }
-        if (filters?.labels && filters.labels.length > 0) {
-          const labelConditions = filters.labels.map(
-            (label) => `(Tags.Name contains "${label}")`
-          );
-          const labelExpr = labelConditions.reduce((acc, cond) => acc ? `(${acc} AND ${cond})` : cond, "");
-          conditions.push(labelExpr);
-        }
-        if (filters?.query) {
-          conditions.push(`((Name contains "${filters.query}") OR (Description contains "${filters.query}"))`);
-        }
-        return conditions.reduce((acc, cond) => acc ? `(${acc} AND ${cond})` : cond, "");
-      }
-      normalizeIssue(rallyArtifact) {
-        const rawStateValue = rallyArtifact.ScheduleState || rallyArtifact.State || "Defined";
-        const stateValue = typeof rawStateValue === "object" && rawStateValue !== null ? rawStateValue.Name || rawStateValue._refObjectName || "Defined" : rawStateValue;
-        const state = this.mapState(stateValue);
-        const labels = [];
-        if (rallyArtifact.Tags && rallyArtifact.Tags._tagsNameArray) {
-          for (const tag of rallyArtifact.Tags._tagsNameArray) {
-            if (typeof tag === "string") {
-              labels.push(tag);
-            } else if (tag?.Name) {
-              labels.push(tag.Name);
-            }
-          }
-        }
-        const priority = rallyArtifact.Priority ? PRIORITY_MAP[rallyArtifact.Priority] ?? 2 : void 0;
-        const objectId = rallyArtifact.ObjectID || rallyArtifact.FormattedID;
-        const artifactType = rallyArtifact._type || "artifact";
-        const baseUrl = this.restApi.server.replace("/slm/webservice/", "");
-        const url = `${baseUrl}/#/detail/${artifactType.toLowerCase()}/${objectId}`;
-        let parentRef;
-        if (rallyArtifact.PortfolioItem) {
-          if (rallyArtifact.PortfolioItem.FormattedID) {
-            parentRef = rallyArtifact.PortfolioItem.FormattedID;
-          } else if (rallyArtifact.PortfolioItem._refObjectName) {
-            parentRef = rallyArtifact.PortfolioItem._refObjectName;
-          }
-        } else if (rallyArtifact.Parent) {
-          if (rallyArtifact.Parent.FormattedID) {
-            parentRef = rallyArtifact.Parent.FormattedID;
-          } else if (rallyArtifact.Parent._refObjectName) {
-            parentRef = rallyArtifact.Parent._refObjectName;
-          }
-        }
-        return {
-          id: String(objectId),
-          ref: rallyArtifact.FormattedID,
-          title: rallyArtifact.Name || "",
-          description: rallyArtifact.Description || "",
-          state,
-          labels,
-          assignee: rallyArtifact.Owner?._refObjectName,
-          url,
-          tracker: "rally",
-          priority,
-          dueDate: rallyArtifact.DueDate,
-          createdAt: rallyArtifact.CreationDate,
-          updatedAt: rallyArtifact.LastUpdateDate,
-          parentRef,
-          artifactType,
-          rawState: stateValue
-        };
-      }
-      mapState(rallyState) {
-        return STATE_MAP2[rallyState] ?? "open";
-      }
-      reverseMapState(state, kind = "story") {
-        if (kind === "feature") {
-          switch (state) {
-            case "open":
-              return "Discovering";
-            case "in_progress":
-              return "Developing";
-            case "closed":
-              return "Done";
-            default:
-              return "Discovering";
-          }
-        }
-        if (kind === "defect") {
-          switch (state) {
-            case "open":
-              return "Submitted";
-            case "in_progress":
-              return "Open";
-            case "closed":
-              return "Closed";
-            default:
-              return "Submitted";
-          }
-        }
-        switch (state) {
-          case "open":
-            return "Defined";
-          case "in_progress":
-            return "In-Progress";
-          case "closed":
-            return "Completed";
-          default:
-            return "Defined";
-        }
-      }
-      // Rally API wrapper methods
-      async queryRally(queryConfig) {
-        const result = await this.restApi.query(queryConfig);
-        return {
-          Results: result.QueryResult.Results,
-          TotalResultCount: result.QueryResult.TotalResultCount
-        };
-      }
-      async createRally(type, data) {
-        const result = await this.restApi.create({
-          type,
-          data,
-          fetch: ["FormattedID", "ObjectID", "_ref"]
-        });
-        return {
-          Object: result.CreateResult.Object
-        };
-      }
-      async updateRally(type, ref, data) {
-        const result = await this.restApi.update({
-          type,
-          ref,
-          data,
-          fetch: ["FormattedID", "ObjectID"]
-        });
-        return {
-          Object: result.OperationResult.Object
-        };
-      }
-    };
-  }
-});
-
-// src/lib/tracker/factory.ts
-function getTrackerKeyFromConfig(trackerType) {
-  try {
-    const yamlConfig = loadConfig();
-    return yamlConfig.trackerKeys[trackerType];
-  } catch {
-    return void 0;
-  }
-}
-function createTracker(config) {
-  switch (config.type) {
-    case "linear": {
-      const configKey = getTrackerKeyFromConfig("linear");
-      const envKey = config.apiKeyEnv ? process.env[config.apiKeyEnv] : process.env.LINEAR_API_KEY;
-      const apiKey = configKey || envKey;
-      if (!apiKey) {
-        throw new TrackerAuthError(
-          "linear",
-          `API key not found. Configure in Settings or set ${config.apiKeyEnv ?? "LINEAR_API_KEY"} environment variable.`
-        );
-      }
-      return new LinearTracker(apiKey, { team: config.team });
-    }
-    case "github": {
-      const configKey = getTrackerKeyFromConfig("github");
-      const envToken = config.tokenEnv ? process.env[config.tokenEnv] : process.env.GITHUB_TOKEN;
-      const token = configKey || envToken;
-      if (!token) {
-        throw new TrackerAuthError(
-          "github",
-          `Token not found. Configure in Settings or set ${config.tokenEnv ?? "GITHUB_TOKEN"} environment variable.`
-        );
-      }
-      if (!config.owner || !config.repo) {
-        throw new Error(
-          "GitHub tracker requires owner and repo configuration"
-        );
-      }
-      return new GitHubTracker(token, config.owner, config.repo);
-    }
-    case "gitlab": {
-      const configKey = getTrackerKeyFromConfig("gitlab");
-      const envToken = config.tokenEnv ? process.env[config.tokenEnv] : process.env.GITLAB_TOKEN;
-      const token = configKey || envToken;
-      if (!token) {
-        throw new TrackerAuthError(
-          "gitlab",
-          `Token not found. Configure in Settings or set ${config.tokenEnv ?? "GITLAB_TOKEN"} environment variable.`
-        );
-      }
-      if (!config.projectId) {
-        throw new Error("GitLab tracker requires projectId configuration");
-      }
-      return new GitLabTracker(token, config.projectId);
-    }
-    case "rally": {
-      const configKey = getTrackerKeyFromConfig("rally");
-      const envKey = config.apiKeyEnv ? process.env[config.apiKeyEnv] : process.env.RALLY_API_KEY;
-      const apiKey = configKey || envKey;
-      if (!apiKey) {
-        throw new TrackerAuthError(
-          "rally",
-          `API key not found. Configure in Settings or set ${config.apiKeyEnv ?? "RALLY_API_KEY"} environment variable.`
-        );
-      }
-      return new RallyTracker({
-        apiKey,
-        server: config.server,
-        workspace: config.workspace,
-        project: config.project
-      });
-    }
-    default:
-      throw new Error(`Unknown tracker type: ${config.type}`);
-  }
-}
-function createTrackerFromConfig(trackersConfig, trackerType) {
-  const config = trackersConfig[trackerType];
-  if (!config) {
-    throw new Error(
-      `No configuration found for tracker: ${trackerType}. Add [trackers.${trackerType}] to config.`
-    );
-  }
-  return createTracker({ ...config, type: trackerType });
-}
-function getPrimaryTracker(trackersConfig) {
-  return createTrackerFromConfig(trackersConfig, trackersConfig.primary);
-}
-function getSecondaryTracker(trackersConfig) {
-  if (!trackersConfig.secondary) {
-    return null;
-  }
-  return createTrackerFromConfig(trackersConfig, trackersConfig.secondary);
-}
-function getAllTrackers(trackersConfig) {
-  const trackers = [getPrimaryTracker(trackersConfig)];
-  const secondary = getSecondaryTracker(trackersConfig);
-  if (secondary) {
-    trackers.push(secondary);
-  }
-  return trackers;
-}
-var init_factory = __esm({
-  "src/lib/tracker/factory.ts"() {
-    "use strict";
-    init_esm_shims();
-    init_interface();
-    init_linear();
-    init_github();
-    init_gitlab();
-    init_rally();
-    init_config_yaml();
-  }
-});
-
-export {
-  loadSettings,
-  saveSettings,
-  validateSettings,
-  getDefaultSettings,
-  getAvailableModels,
-  isAnthropicModel,
-  getClaudeModelFlag,
-  getAgentCommand,
-  init_settings,
-  PROVIDERS,
-  getProviderForModel,
-  requiresRouter,
-  getRouterProviders,
-  getDirectProviders,
-  needsRouter,
-  getProviderEnv,
-  init_providers,
-  NotImplementedError,
-  IssueNotFoundError,
-  TrackerAuthError,
-  init_interface,
-  LinearTracker,
-  init_linear,
-  GitHubTracker,
-  init_github,
-  GitLabTracker,
-  init_gitlab,
-  createTracker,
-  createTrackerFromConfig,
-  getPrimaryTracker,
-  getSecondaryTracker,
-  getAllTrackers,
-  init_factory
-};
-//# sourceMappingURL=chunk-LYSBSZYV.js.map