panopticon-cli 0.1.3 → 0.1.6

package/dist/chunk-RM3WGTFO.js

@@ -0,0 +1,1058 @@
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+var __commonJS = (cb, mod) => function __require2() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+
+// src/lib/paths.ts
+import { homedir } from "os";
+import { join } from "path";
+import { fileURLToPath } from "url";
+import { dirname } from "path";
+var PANOPTICON_HOME = join(homedir(), ".panopticon");
+var CONFIG_DIR = PANOPTICON_HOME;
+var SKILLS_DIR = join(PANOPTICON_HOME, "skills");
+var COMMANDS_DIR = join(PANOPTICON_HOME, "commands");
+var AGENTS_DIR = join(PANOPTICON_HOME, "agents");
+var BACKUPS_DIR = join(PANOPTICON_HOME, "backups");
+var COSTS_DIR = join(PANOPTICON_HOME, "costs");
+var TRAEFIK_DIR = join(PANOPTICON_HOME, "traefik");
+var TRAEFIK_DYNAMIC_DIR = join(TRAEFIK_DIR, "dynamic");
+var TRAEFIK_CERTS_DIR = join(TRAEFIK_DIR, "certs");
+var CERTS_DIR = join(PANOPTICON_HOME, "certs");
+var CONFIG_FILE = join(CONFIG_DIR, "config.toml");
+var CLAUDE_DIR = join(homedir(), ".claude");
+var CODEX_DIR = join(homedir(), ".codex");
+var CURSOR_DIR = join(homedir(), ".cursor");
+var GEMINI_DIR = join(homedir(), ".gemini");
+var SYNC_TARGETS = {
+  claude: {
+    skills: join(CLAUDE_DIR, "skills"),
+    commands: join(CLAUDE_DIR, "commands")
+  },
+  codex: {
+    skills: join(CODEX_DIR, "skills"),
+    commands: join(CODEX_DIR, "commands")
+  },
+  cursor: {
+    skills: join(CURSOR_DIR, "skills"),
+    commands: join(CURSOR_DIR, "commands")
+  },
+  gemini: {
+    skills: join(GEMINI_DIR, "skills"),
+    commands: join(GEMINI_DIR, "commands")
+  }
+};
+var TEMPLATES_DIR = join(PANOPTICON_HOME, "templates");
+var CLAUDE_MD_TEMPLATES = join(TEMPLATES_DIR, "claude-md", "sections");
+var currentFile = fileURLToPath(import.meta.url);
+var distDir = dirname(currentFile);
+var packageRoot = dirname(distDir);
+var SOURCE_TEMPLATES_DIR = join(packageRoot, "templates");
+var SOURCE_TRAEFIK_TEMPLATES = join(SOURCE_TEMPLATES_DIR, "traefik");
+var INIT_DIRS = [
+  PANOPTICON_HOME,
+  SKILLS_DIR,
+  COMMANDS_DIR,
+  AGENTS_DIR,
+  BACKUPS_DIR,
+  COSTS_DIR,
+  TEMPLATES_DIR,
+  CLAUDE_MD_TEMPLATES,
+  CERTS_DIR,
+  TRAEFIK_DIR,
+  TRAEFIK_DYNAMIC_DIR,
+  TRAEFIK_CERTS_DIR
+];
+
+// src/lib/config.ts
+import { readFileSync, writeFileSync, existsSync } from "fs";
+import { parse, stringify } from "@iarna/toml";
+var DEFAULT_CONFIG = {
+  panopticon: {
+    version: "1.0.0"
+  },
+  sync: {
+    targets: ["claude"],
+    backup_before_sync: true,
+    auto_sync: false,
+    strategy: "symlink"
+  },
+  trackers: {
+    primary: "linear",
+    linear: {
+      type: "linear",
+      api_key_env: "LINEAR_API_KEY"
+    }
+  },
+  dashboard: {
+    port: 3001,
+    api_port: 3002
+  }
+};
+function loadConfig() {
+  if (!existsSync(CONFIG_FILE)) {
+    return DEFAULT_CONFIG;
+  }
+  try {
+    const content = readFileSync(CONFIG_FILE, "utf8");
+    const parsed = parse(content);
+    return { ...DEFAULT_CONFIG, ...parsed };
+  } catch (error) {
+    console.error("Warning: Failed to parse config, using defaults");
+    return DEFAULT_CONFIG;
+  }
+}
+function saveConfig(config) {
+  const content = stringify(config);
+  writeFileSync(CONFIG_FILE, content, "utf8");
+}
+function getDefaultConfig() {
+  return { ...DEFAULT_CONFIG };
+}
+
+// src/lib/shell.ts
+import { existsSync as existsSync2, readFileSync as readFileSync2, appendFileSync } from "fs";
+import { homedir as homedir2 } from "os";
+import { join as join2 } 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 = homedir2();
+  switch (shell) {
+    case "zsh":
+      return join2(home, ".zshrc");
+    case "bash":
+      const bashrc = join2(home, ".bashrc");
+      if (existsSync2(bashrc)) return bashrc;
+      return join2(home, ".bash_profile");
+    case "fish":
+      return join2(home, ".config", "fish", "config.fish");
+    default:
+      return null;
+  }
+}
+var ALIAS_LINE = 'alias pan="panopticon"';
+var ALIAS_MARKER = "# Panopticon CLI alias";
+function hasAlias(rcFile) {
+  if (!existsSync2(rcFile)) return false;
+  const content = readFileSync2(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
+import { existsSync as existsSync3, mkdirSync, readdirSync, cpSync, rmSync } from "fs";
+import { join as join3, basename } from "path";
+function createBackupTimestamp() {
+  return (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
+}
+function createBackup(sourceDirs) {
+  const timestamp = createBackupTimestamp();
+  const backupPath = join3(BACKUPS_DIR, timestamp);
+  mkdirSync(backupPath, { recursive: true });
+  const targets = [];
+  for (const sourceDir of sourceDirs) {
+    if (!existsSync3(sourceDir)) continue;
+    const targetName = basename(sourceDir);
+    const targetPath = join3(backupPath, targetName);
+    cpSync(sourceDir, targetPath, { recursive: true });
+    targets.push(targetName);
+  }
+  return {
+    timestamp,
+    path: backupPath,
+    targets
+  };
+}
+function listBackups() {
+  if (!existsSync3(BACKUPS_DIR)) return [];
+  const entries = readdirSync(BACKUPS_DIR, { withFileTypes: true });
+  return entries.filter((e) => e.isDirectory()).map((e) => {
+    const backupPath = join3(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 = join3(BACKUPS_DIR, timestamp);
+  if (!existsSync3(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 = join3(backupPath, entry.name);
+    const targetPath = targetDirs[entry.name];
+    if (!targetPath) continue;
+    if (existsSync3(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
+import { existsSync as existsSync4, mkdirSync as mkdirSync2, readdirSync as readdirSync2, symlinkSync, unlinkSync, lstatSync, readlinkSync, rmSync as rmSync2 } from "fs";
+import { join as join4 } from "path";
+function removeTarget(targetPath) {
+  const stats = lstatSync(targetPath);
+  if (stats.isDirectory() && !stats.isSymbolicLink()) {
+    rmSync2(targetPath, { recursive: true, force: true });
+  } else {
+    unlinkSync(targetPath);
+  }
+}
+function isPanopticonSymlink(targetPath) {
+  if (!existsSync4(targetPath)) return false;
+  try {
+    const stats = lstatSync(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];
+  const plan = {
+    runtime,
+    skills: [],
+    commands: []
+  };
+  if (existsSync4(SKILLS_DIR)) {
+    const skills = readdirSync2(SKILLS_DIR, { withFileTypes: true }).filter((d) => d.isDirectory());
+    for (const skill of skills) {
+      const sourcePath = join4(SKILLS_DIR, skill.name);
+      const targetPath = join4(targets.skills, skill.name);
+      let status = "new";
+      if (existsSync4(targetPath)) {
+        if (isPanopticonSymlink(targetPath)) {
+          status = "symlink";
+        } else {
+          status = "conflict";
+        }
+      }
+      plan.skills.push({ name: skill.name, sourcePath, targetPath, status });
+    }
+  }
+  if (existsSync4(COMMANDS_DIR)) {
+    const commands = readdirSync2(COMMANDS_DIR, { withFileTypes: true }).filter((d) => d.isDirectory());
+    for (const cmd of commands) {
+      const sourcePath = join4(COMMANDS_DIR, cmd.name);
+      const targetPath = join4(targets.commands, cmd.name);
+      let status = "new";
+      if (existsSync4(targetPath)) {
+        if (isPanopticonSymlink(targetPath)) {
+          status = "symlink";
+        } else {
+          status = "conflict";
+        }
+      }
+      plan.commands.push({ name: cmd.name, sourcePath, targetPath, status });
+    }
+  }
+  return plan;
+}
+function executeSync(runtime, options = {}) {
+  const plan = planSync(runtime);
+  const result = {
+    created: [],
+    skipped: [],
+    conflicts: []
+  };
+  const targets = SYNC_TARGETS[runtime];
+  mkdirSync2(targets.skills, { recursive: true });
+  mkdirSync2(targets.commands, { 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 (existsSync4(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 (existsSync4(item.targetPath)) {
+      removeTarget(item.targetPath);
+    }
+    symlinkSync(item.sourcePath, item.targetPath);
+    result.created.push(item.name);
+  }
+  return result;
+}
+
+// src/lib/tracker/interface.ts
+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
+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
+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
+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
+function createTracker(config) {
+  switch (config.type) {
+    case "linear": {
+      const apiKey = config.apiKeyEnv ? process.env[config.apiKeyEnv] : process.env.LINEAR_API_KEY;
+      if (!apiKey) {
+        throw new TrackerAuthError(
+          "linear",
+          `API key not found. Set ${config.apiKeyEnv ?? "LINEAR_API_KEY"} environment variable.`
+        );
+      }
+      return new LinearTracker(apiKey, { team: config.team });
+    }
+    case "github": {
+      const token = config.tokenEnv ? process.env[config.tokenEnv] : process.env.GITHUB_TOKEN;
+      if (!token) {
+        throw new TrackerAuthError(
+          "github",
+          `Token not found. 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 token = config.tokenEnv ? process.env[config.tokenEnv] : process.env.GITLAB_TOKEN;
+      if (!token) {
+        throw new TrackerAuthError(
+          "gitlab",
+          `Token not found. Set ${config.tokenEnv ?? "GITLAB_TOKEN"} environment variable.`
+        );
+      }
+      if (!config.projectId) {
+        throw new Error("GitLab tracker requires projectId configuration");
+      }
+      return new GitLabTracker(token, config.projectId);
+    }
+    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
+import { readFileSync as readFileSync3, writeFileSync as writeFileSync2, existsSync as existsSync5, mkdirSync as mkdirSync3 } from "fs";
+import { join as join5 } from "path";
+import { homedir as homedir3 } 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 ?? join5(homedir3(), ".panopticon", "links.json");
+    this.store = this.load();
+  }
+  load() {
+    if (existsSync5(this.storePath)) {
+      try {
+        const data = JSON.parse(readFileSync3(this.storePath, "utf-8"));
+        if (data.version === 1) {
+          return data;
+        }
+      } catch {
+      }
+    }
+    return { version: 1, links: [] };
+  }
+  save() {
+    const dir = join5(this.storePath, "..");
+    if (!existsSync5(dir)) {
+      mkdirSync3(dir, { recursive: true });
+    }
+    writeFileSync2(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;
+}
+
+export {
+  __require,
+  __commonJS,
+  PANOPTICON_HOME,
+  CONFIG_DIR,
+  SKILLS_DIR,
+  COMMANDS_DIR,
+  AGENTS_DIR,
+  BACKUPS_DIR,
+  COSTS_DIR,
+  TRAEFIK_DIR,
+  TRAEFIK_DYNAMIC_DIR,
+  TRAEFIK_CERTS_DIR,
+  CERTS_DIR,
+  CONFIG_FILE,
+  CLAUDE_DIR,
+  CODEX_DIR,
+  CURSOR_DIR,
+  GEMINI_DIR,
+  SYNC_TARGETS,
+  TEMPLATES_DIR,
+  CLAUDE_MD_TEMPLATES,
+  SOURCE_TEMPLATES_DIR,
+  SOURCE_TRAEFIK_TEMPLATES,
+  INIT_DIRS,
+  loadConfig,
+  saveConfig,
+  getDefaultConfig,
+  detectShell,
+  getShellRcFile,
+  hasAlias,
+  addAlias,
+  getAliasInstructions,
+  createBackupTimestamp,
+  createBackup,
+  listBackups,
+  restoreBackup,
+  cleanOldBackups,
+  isPanopticonSymlink,
+  planSync,
+  executeSync,
+  NotImplementedError,
+  IssueNotFoundError,
+  TrackerAuthError,
+  LinearTracker,
+  GitHubTracker,
+  GitLabTracker,
+  createTracker,
+  createTrackerFromConfig,
+  getPrimaryTracker,
+  getSecondaryTracker,
+  getAllTrackers,
+  parseIssueRef,
+  formatIssueRef,
+  LinkManager,
+  getLinkManager
+};
+//# sourceMappingURL=chunk-RM3WGTFO.js.map