panopticon-cli 0.4.28 → 0.4.31

package/dist/chunk-SUMIHS2B.js

@@ -1,1714 +0,0 @@
-import {
-  init_config_yaml,
-  loadConfig
-} from "./chunk-BBCUK6N2.js";
-import {
-  AGENTS_DIR,
-  BACKUPS_DIR,
-  BIN_DIR,
-  COMMANDS_DIR,
-  SKILLS_DIR,
-  SOURCE_DEV_SKILLS_DIR,
-  SOURCE_SCRIPTS_DIR,
-  SYNC_TARGETS,
-  init_paths,
-  isDevMode
-} from "./chunk-6HXKTOD7.js";
-import {
-  init_esm_shims
-} from "./chunk-ZHC57RCV.js";
-
-// src/lib/shell.ts
-init_esm_shims();
-import { existsSync, readFileSync, appendFileSync } from "fs";
-import { homedir } from "os";
-import { join } from "path";
-function detectShell() {
-  const shell = process.env.SHELL || "";
-  if (shell.includes("zsh")) return "zsh";
-  if (shell.includes("bash")) return "bash";
-  if (shell.includes("fish")) return "fish";
-  return "unknown";
-}
-function getShellRcFile(shell) {
-  const home = homedir();
-  switch (shell) {
-    case "zsh":
-      return join(home, ".zshrc");
-    case "bash":
-      const bashrc = join(home, ".bashrc");
-      if (existsSync(bashrc)) return bashrc;
-      return join(home, ".bash_profile");
-    case "fish":
-      return join(home, ".config", "fish", "config.fish");
-    default:
-      return null;
-  }
-}
-var ALIAS_LINE = 'alias pan="panopticon"';
-var ALIAS_MARKER = "# Panopticon CLI alias";
-function hasAlias(rcFile) {
-  if (!existsSync(rcFile)) return false;
-  const content = readFileSync(rcFile, "utf8");
-  return content.includes(ALIAS_MARKER) || content.includes(ALIAS_LINE);
-}
-function addAlias(rcFile) {
-  if (hasAlias(rcFile)) return;
-  const aliasBlock = `
-${ALIAS_MARKER}
-${ALIAS_LINE}
-`;
-  appendFileSync(rcFile, aliasBlock, "utf8");
-}
-function getAliasInstructions(shell) {
-  const rcFile = getShellRcFile(shell);
-  if (!rcFile) {
-    return `Add this to your shell config:
-  ${ALIAS_LINE}`;
-  }
-  return `Alias added to ${rcFile}. Run:
-  source ${rcFile}`;
-}
-
-// src/lib/backup.ts
-init_esm_shims();
-init_paths();
-import { existsSync as existsSync2, mkdirSync, readdirSync, cpSync, rmSync, lstatSync } from "fs";
-import { join as join2, basename } from "path";
-function createBackupTimestamp() {
-  return (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
-}
-function createBackup(sourceDirs) {
-  const timestamp = createBackupTimestamp();
-  const backupPath = join2(BACKUPS_DIR, timestamp);
-  mkdirSync(backupPath, { recursive: true });
-  const targets = [];
-  for (const sourceDir of sourceDirs) {
-    if (!existsSync2(sourceDir)) continue;
-    const targetName = basename(sourceDir);
-    const targetPath = join2(backupPath, targetName);
-    cpSync(sourceDir, targetPath, {
-      recursive: true,
-      filter: (src) => !lstatSync(src).isSymbolicLink()
-    });
-    targets.push(targetName);
-  }
-  return {
-    timestamp,
-    path: backupPath,
-    targets
-  };
-}
-function listBackups() {
-  if (!existsSync2(BACKUPS_DIR)) return [];
-  const entries = readdirSync(BACKUPS_DIR, { withFileTypes: true });
-  return entries.filter((e) => e.isDirectory()).map((e) => {
-    const backupPath = join2(BACKUPS_DIR, e.name);
-    const contents = readdirSync(backupPath);
-    return {
-      timestamp: e.name,
-      path: backupPath,
-      targets: contents
-    };
-  }).sort((a, b) => b.timestamp.localeCompare(a.timestamp));
-}
-function restoreBackup(timestamp, targetDirs) {
-  const backupPath = join2(BACKUPS_DIR, timestamp);
-  if (!existsSync2(backupPath)) {
-    throw new Error(`Backup not found: ${timestamp}`);
-  }
-  const contents = readdirSync(backupPath, { withFileTypes: true });
-  for (const entry of contents) {
-    if (!entry.isDirectory()) continue;
-    const sourcePath = join2(backupPath, entry.name);
-    const targetPath = targetDirs[entry.name];
-    if (!targetPath) continue;
-    if (existsSync2(targetPath)) {
-      rmSync(targetPath, { recursive: true });
-    }
-    cpSync(sourcePath, targetPath, { recursive: true });
-  }
-}
-function cleanOldBackups(keepCount = 10) {
-  const backups = listBackups();
-  if (backups.length <= keepCount) return 0;
-  const toRemove = backups.slice(keepCount);
-  let removed = 0;
-  for (const backup of toRemove) {
-    rmSync(backup.path, { recursive: true });
-    removed++;
-  }
-  return removed;
-}
-
-// src/lib/sync.ts
-init_esm_shims();
-init_paths();
-import { existsSync as existsSync3, mkdirSync as mkdirSync2, readdirSync as readdirSync2, symlinkSync, unlinkSync, lstatSync as lstatSync2, readlinkSync, rmSync as rmSync2, copyFileSync, chmodSync } from "fs";
-import { join as join3 } from "path";
-function removeTarget(targetPath) {
-  const stats = lstatSync2(targetPath);
-  if (stats.isDirectory() && !stats.isSymbolicLink()) {
-    rmSync2(targetPath, { recursive: true, force: true });
-  } else {
-    unlinkSync(targetPath);
-  }
-}
-function isPanopticonSymlink(targetPath) {
-  if (!existsSync3(targetPath)) return false;
-  try {
-    const stats = lstatSync2(targetPath);
-    if (!stats.isSymbolicLink()) return false;
-    const linkTarget = readlinkSync(targetPath);
-    return linkTarget.includes(".panopticon");
-  } catch {
-    return false;
-  }
-}
-function planSync(runtime) {
-  const targets = SYNC_TARGETS[runtime];
-  if (!targets) {
-    throw new Error(`Unknown sync target "${runtime}". Valid targets: ${Object.keys(SYNC_TARGETS).join(", ")}`);
-  }
-  const plan = {
-    runtime,
-    skills: [],
-    commands: [],
-    agents: [],
-    devSkills: []
-  };
-  if (existsSync3(SKILLS_DIR)) {
-    const skills = readdirSync2(SKILLS_DIR, { withFileTypes: true }).filter((d) => d.isDirectory());
-    for (const skill of skills) {
-      const sourcePath = join3(SKILLS_DIR, skill.name);
-      const targetPath = join3(targets.skills, skill.name);
-      let status = "new";
-      if (existsSync3(targetPath)) {
-        if (isPanopticonSymlink(targetPath)) {
-          status = "symlink";
-        } else {
-          status = "conflict";
-        }
-      }
-      plan.skills.push({ name: skill.name, sourcePath, targetPath, status });
-    }
-  }
-  if (isDevMode() && existsSync3(SOURCE_DEV_SKILLS_DIR)) {
-    const devSkills = readdirSync2(SOURCE_DEV_SKILLS_DIR, { withFileTypes: true }).filter((d) => d.isDirectory());
-    for (const skill of devSkills) {
-      const sourcePath = join3(SOURCE_DEV_SKILLS_DIR, skill.name);
-      const targetPath = join3(targets.skills, skill.name);
-      let status = "new";
-      if (existsSync3(targetPath)) {
-        if (isPanopticonSymlink(targetPath)) {
-          status = "symlink";
-        } else {
-          status = "conflict";
-        }
-      }
-      plan.devSkills.push({ name: skill.name, sourcePath, targetPath, status });
-    }
-  }
-  if (existsSync3(COMMANDS_DIR)) {
-    const commands = readdirSync2(COMMANDS_DIR, { withFileTypes: true }).filter((d) => d.isDirectory());
-    for (const cmd of commands) {
-      const sourcePath = join3(COMMANDS_DIR, cmd.name);
-      const targetPath = join3(targets.commands, cmd.name);
-      let status = "new";
-      if (existsSync3(targetPath)) {
-        if (isPanopticonSymlink(targetPath)) {
-          status = "symlink";
-        } else {
-          status = "conflict";
-        }
-      }
-      plan.commands.push({ name: cmd.name, sourcePath, targetPath, status });
-    }
-  }
-  if (existsSync3(AGENTS_DIR)) {
-    const agents = readdirSync2(AGENTS_DIR, { withFileTypes: true }).filter((entry) => entry.isFile() && entry.name.endsWith(".md"));
-    for (const agent of agents) {
-      const sourcePath = join3(AGENTS_DIR, agent.name);
-      const targetPath = join3(targets.agents, agent.name);
-      let status = "new";
-      if (existsSync3(targetPath)) {
-        if (isPanopticonSymlink(targetPath)) {
-          status = "symlink";
-        } else {
-          status = "conflict";
-        }
-      }
-      plan.agents.push({ name: agent.name, sourcePath, targetPath, status });
-    }
-  }
-  return plan;
-}
-function executeSync(runtime, options = {}) {
-  const targets = SYNC_TARGETS[runtime];
-  if (!targets) {
-    throw new Error(`Unknown sync target "${runtime}". Valid targets: ${Object.keys(SYNC_TARGETS).join(", ")}`);
-  }
-  const plan = planSync(runtime);
-  const result = {
-    created: [],
-    skipped: [],
-    conflicts: []
-  };
-  mkdirSync2(targets.skills, { recursive: true });
-  mkdirSync2(targets.commands, { recursive: true });
-  mkdirSync2(targets.agents, { recursive: true });
-  for (const item of plan.skills) {
-    if (options.dryRun) {
-      if (item.status === "new" || item.status === "symlink") {
-        result.created.push(item.name);
-      } else {
-        result.conflicts.push(item.name);
-      }
-      continue;
-    }
-    if (item.status === "conflict" && !options.force) {
-      result.conflicts.push(item.name);
-      continue;
-    }
-    if (existsSync3(item.targetPath)) {
-      removeTarget(item.targetPath);
-    }
-    symlinkSync(item.sourcePath, item.targetPath);
-    result.created.push(item.name);
-  }
-  for (const item of plan.commands) {
-    if (options.dryRun) {
-      if (item.status === "new" || item.status === "symlink") {
-        result.created.push(item.name);
-      } else {
-        result.conflicts.push(item.name);
-      }
-      continue;
-    }
-    if (item.status === "conflict" && !options.force) {
-      result.conflicts.push(item.name);
-      continue;
-    }
-    if (existsSync3(item.targetPath)) {
-      removeTarget(item.targetPath);
-    }
-    symlinkSync(item.sourcePath, item.targetPath);
-    result.created.push(item.name);
-  }
-  for (const item of plan.agents) {
-    if (options.dryRun) {
-      if (item.status === "new" || item.status === "symlink") {
-        result.created.push(item.name);
-      } else {
-        result.conflicts.push(item.name);
-      }
-      continue;
-    }
-    if (item.status === "conflict" && !options.force) {
-      result.conflicts.push(item.name);
-      continue;
-    }
-    if (existsSync3(item.targetPath)) {
-      removeTarget(item.targetPath);
-    }
-    symlinkSync(item.sourcePath, item.targetPath);
-    result.created.push(item.name);
-  }
-  for (const item of plan.devSkills) {
-    if (options.dryRun) {
-      if (item.status === "new" || item.status === "symlink") {
-        result.created.push(`${item.name} (dev)`);
-      } else {
-        result.conflicts.push(`${item.name} (dev)`);
-      }
-      continue;
-    }
-    if (item.status === "conflict" && !options.force) {
-      result.conflicts.push(`${item.name} (dev)`);
-      continue;
-    }
-    if (existsSync3(item.targetPath)) {
-      removeTarget(item.targetPath);
-    }
-    symlinkSync(item.sourcePath, item.targetPath);
-    result.created.push(`${item.name} (dev)`);
-  }
-  return result;
-}
-function planHooksSync() {
-  const hooks = [];
-  if (!existsSync3(SOURCE_SCRIPTS_DIR)) {
-    return hooks;
-  }
-  const scripts = readdirSync2(SOURCE_SCRIPTS_DIR, { withFileTypes: true }).filter((entry) => entry.isFile() && !entry.name.startsWith(".") && !entry.name.includes("."));
-  for (const script of scripts) {
-    const sourcePath = join3(SOURCE_SCRIPTS_DIR, script.name);
-    const targetPath = join3(BIN_DIR, script.name);
-    let status = "new";
-    if (existsSync3(targetPath)) {
-      status = "updated";
-    }
-    hooks.push({ name: script.name, sourcePath, targetPath, status });
-  }
-  return hooks;
-}
-function syncHooks() {
-  const result = { synced: [], errors: [] };
-  mkdirSync2(BIN_DIR, { recursive: true });
-  const hooks = planHooksSync();
-  for (const hook of hooks) {
-    try {
-      copyFileSync(hook.sourcePath, hook.targetPath);
-      chmodSync(hook.targetPath, 493);
-      result.synced.push(hook.name);
-    } catch (error) {
-      result.errors.push(`${hook.name}: ${error}`);
-    }
-  }
-  return result;
-}
-
-// src/lib/tracker/interface.ts
-init_esm_shims();
-var NotImplementedError = class extends Error {
-  constructor(feature) {
-    super(`Not implemented: ${feature}`);
-    this.name = "NotImplementedError";
-  }
-};
-var IssueNotFoundError = class extends Error {
-  constructor(id, tracker) {
-    super(`Issue not found: ${id} (tracker: ${tracker})`);
-    this.name = "IssueNotFoundError";
-  }
-};
-var TrackerAuthError = class extends Error {
-  constructor(tracker, message) {
-    super(`Authentication failed for ${tracker}: ${message}`);
-    this.name = "TrackerAuthError";
-  }
-};
-
-// src/lib/tracker/linear.ts
-init_esm_shims();
-import { LinearClient } from "@linear/sdk";
-var STATE_MAP = {
-  backlog: "open",
-  unstarted: "open",
-  started: "in_progress",
-  completed: "closed",
-  canceled: "closed"
-};
-var 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) {
-    const issue = await this.getIssue(id);
-    const linearIssue = await this.client.issue(issue.id);
-    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 targetState = states.nodes.find((s) => s.type === targetStateType);
-    if (!targetState) {
-      throw new Error(`No state found matching type: ${targetStateType}`);
-    }
-    await this.client.updateIssue(issue.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
-init_esm_shims();
-import { Octokit } from "@octokit/rest";
-var 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
-init_esm_shims();
-var 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/factory.ts
-init_esm_shims();
-
-// src/lib/tracker/rally.ts
-init_esm_shims();
-
-// src/lib/tracker/rally-api.ts
-init_esm_shims();
-var 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 = {
-  // 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"
-};
-var 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"] }
-];
-var FETCH_FIELDS = [
-  "ObjectID",
-  "FormattedID",
-  "Name",
-  "Description",
-  "ScheduleState",
-  "State",
-  "Tags",
-  "Owner",
-  "Priority",
-  "DueDate",
-  "CreationDate",
-  "LastUpdateDate",
-  "Parent",
-  "PortfolioItem",
-  "_type"
-];
-var PRIORITY_MAP = {
-  "Resolve Immediately": 0,
-  High: 1,
-  Normal: 2,
-  Low: 3
-};
-var REVERSE_PRIORITY_MAP = {
-  0: "Resolve Immediately",
-  1: "High",
-  2: "Normal",
-  3: "Low",
-  4: "Low"
-};
-var 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
-init_config_yaml();
-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;
-}
-
-// src/lib/tracker/linking.ts
-init_esm_shims();
-import { readFileSync as readFileSync2, writeFileSync, existsSync as existsSync4, mkdirSync as mkdirSync3 } from "fs";
-import { join as join4 } from "path";
-import { homedir as homedir2 } from "os";
-function parseIssueRef(ref) {
-  if (ref.startsWith("github#")) {
-    return { tracker: "github", ref: `#${ref.slice(7)}` };
-  }
-  if (ref.startsWith("gitlab#")) {
-    return { tracker: "gitlab", ref: `#${ref.slice(7)}` };
-  }
-  if (ref.startsWith("linear:")) {
-    return { tracker: "linear", ref: ref.slice(7) };
-  }
-  if (/^#\d+$/.test(ref)) {
-    return { tracker: "github", ref };
-  }
-  if (/^[A-Z]+-\d+$/i.test(ref)) {
-    return { tracker: "linear", ref: ref.toUpperCase() };
-  }
-  return null;
-}
-function formatIssueRef(ref, tracker) {
-  if (tracker === "github") {
-    return ref.startsWith("#") ? `github${ref}` : `github#${ref}`;
-  }
-  if (tracker === "gitlab") {
-    return ref.startsWith("#") ? `gitlab${ref}` : `gitlab#${ref}`;
-  }
-  return ref;
-}
-var LinkManager = class {
-  storePath;
-  store;
-  constructor(storePath) {
-    this.storePath = storePath ?? join4(homedir2(), ".panopticon", "links.json");
-    this.store = this.load();
-  }
-  load() {
-    if (existsSync4(this.storePath)) {
-      try {
-        const data = JSON.parse(readFileSync2(this.storePath, "utf-8"));
-        if (data.version === 1) {
-          return data;
-        }
-      } catch {
-      }
-    }
-    return { version: 1, links: [] };
-  }
-  save() {
-    const dir = join4(this.storePath, "..");
-    if (!existsSync4(dir)) {
-      mkdirSync3(dir, { recursive: true });
-    }
-    writeFileSync(this.storePath, JSON.stringify(this.store, null, 2));
-  }
-  /**
-   * Add a link between two issues
-   */
-  addLink(source, target, direction = "related") {
-    const existing = this.store.links.find(
-      (l) => l.sourceIssueRef === source.ref && l.sourceTracker === source.tracker && l.targetIssueRef === target.ref && l.targetTracker === target.tracker
-    );
-    if (existing) {
-      if (existing.direction !== direction) {
-        existing.direction = direction;
-        this.save();
-      }
-      return existing;
-    }
-    const link = {
-      sourceIssueRef: source.ref,
-      sourceTracker: source.tracker,
-      targetIssueRef: target.ref,
-      targetTracker: target.tracker,
-      direction,
-      createdAt: (/* @__PURE__ */ new Date()).toISOString()
-    };
-    this.store.links.push(link);
-    this.save();
-    return link;
-  }
-  /**
-   * Remove a link between two issues
-   */
-  removeLink(source, target) {
-    const index = this.store.links.findIndex(
-      (l) => l.sourceIssueRef === source.ref && l.sourceTracker === source.tracker && l.targetIssueRef === target.ref && l.targetTracker === target.tracker
-    );
-    if (index >= 0) {
-      this.store.links.splice(index, 1);
-      this.save();
-      return true;
-    }
-    return false;
-  }
-  /**
-   * Get all issues linked to a given issue
-   */
-  getLinkedIssues(ref, tracker) {
-    return this.store.links.filter(
-      (l) => l.sourceIssueRef === ref && l.sourceTracker === tracker || l.targetIssueRef === ref && l.targetTracker === tracker
-    );
-  }
-  /**
-   * Get all links (for debugging/admin)
-   */
-  getAllLinks() {
-    return [...this.store.links];
-  }
-  /**
-   * Find linked issue in another tracker
-   */
-  findLinkedIssue(ref, sourceTracker, targetTracker) {
-    const asSource = this.store.links.find(
-      (l) => l.sourceIssueRef === ref && l.sourceTracker === sourceTracker && l.targetTracker === targetTracker
-    );
-    if (asSource) return asSource.targetIssueRef;
-    const asTarget = this.store.links.find(
-      (l) => l.targetIssueRef === ref && l.targetTracker === sourceTracker && l.sourceTracker === targetTracker
-    );
-    if (asTarget) return asTarget.sourceIssueRef;
-    return null;
-  }
-  /**
-   * Clear all links (for testing)
-   */
-  clear() {
-    this.store.links = [];
-    this.save();
-  }
-};
-var _linkManager = null;
-function getLinkManager() {
-  if (!_linkManager) {
-    _linkManager = new LinkManager();
-  }
-  return _linkManager;
-}
-
-// src/lib/tracker/index.ts
-init_esm_shims();
-
-export {
-  detectShell,
-  getShellRcFile,
-  hasAlias,
-  addAlias,
-  getAliasInstructions,
-  createBackupTimestamp,
-  createBackup,
-  listBackups,
-  restoreBackup,
-  cleanOldBackups,
-  isPanopticonSymlink,
-  planSync,
-  executeSync,
-  planHooksSync,
-  syncHooks,
-  NotImplementedError,
-  IssueNotFoundError,
-  TrackerAuthError,
-  LinearTracker,
-  GitHubTracker,
-  GitLabTracker,
-  createTracker,
-  createTrackerFromConfig,
-  getPrimaryTracker,
-  getSecondaryTracker,
-  getAllTrackers,
-  parseIssueRef,
-  formatIssueRef,
-  LinkManager,
-  getLinkManager
-};
-//# sourceMappingURL=chunk-SUMIHS2B.js.map