panopticon-cli 0.2.0 → 0.3.0

package/dist/{chunk-J7JUNJGH.js → chunk-B2JBBOJN.js}

@@ -1,76 +1,19 @@
-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,
+import {
   AGENTS_DIR,
   BACKUPS_DIR,
-  COSTS_DIR,
-  TEMPLATES_DIR,
-  CLAUDE_MD_TEMPLATES,
-  CERTS_DIR,
-  TRAEFIK_DIR,
-  TRAEFIK_DYNAMIC_DIR,
-  TRAEFIK_CERTS_DIR
-];
+  BIN_DIR,
+  COMMANDS_DIR,
+  CONFIG_FILE,
+  SKILLS_DIR,
+  SOURCE_SCRIPTS_DIR,
+  SYNC_TARGETS,
+  init_esm_shims,
+  init_paths
+} from "./chunk-SG7O6I7R.js";
 
 // src/lib/config.ts
+init_esm_shims();
+init_paths();
 import { readFileSync, writeFileSync, existsSync } from "fs";
 import { parse, stringify } from "@iarna/toml";
 var DEFAULT_CONFIG = {
@@ -95,6 +38,20 @@ var DEFAULT_CONFIG = {
     api_port: 3002
   }
 };
+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 loadConfig() {
   if (!existsSync(CONFIG_FILE)) {
     return DEFAULT_CONFIG;
@@ -102,7 +59,7 @@ function loadConfig() {
   try {
     const content = readFileSync(CONFIG_FILE, "utf8");
     const parsed = parse(content);
-    return { ...DEFAULT_CONFIG, ...parsed };
+    return deepMerge(DEFAULT_CONFIG, parsed);
   } catch (error) {
     console.error("Warning: Failed to parse config, using defaults");
     return DEFAULT_CONFIG;
@@ -117,9 +74,10 @@ function getDefaultConfig() {
 }
 
 // src/lib/shell.ts
+init_esm_shims();
 import { existsSync as existsSync2, readFileSync as readFileSync2, appendFileSync } from "fs";
-import { homedir as homedir2 } from "os";
-import { join as join2 } from "path";
+import { homedir } from "os";
+import { join } from "path";
 function detectShell() {
   const shell = process.env.SHELL || "";
   if (shell.includes("zsh")) return "zsh";
@@ -128,16 +86,16 @@ function detectShell() {
   return "unknown";
 }
 function getShellRcFile(shell) {
-  const home = homedir2();
+  const home = homedir();
   switch (shell) {
     case "zsh":
-      return join2(home, ".zshrc");
+      return join(home, ".zshrc");
     case "bash":
-      const bashrc = join2(home, ".bashrc");
+      const bashrc = join(home, ".bashrc");
       if (existsSync2(bashrc)) return bashrc;
-      return join2(home, ".bash_profile");
+      return join(home, ".bash_profile");
     case "fish":
-      return join2(home, ".config", "fish", "config.fish");
+      return join(home, ".config", "fish", "config.fish");
     default:
       return null;
   }
@@ -168,20 +126,22 @@ function getAliasInstructions(shell) {
 }
 
 // src/lib/backup.ts
+init_esm_shims();
+init_paths();
 import { existsSync as existsSync3, mkdirSync, readdirSync, cpSync, rmSync } from "fs";
-import { join as join3, basename } from "path";
+import { join as join2, basename } from "path";
 function createBackupTimestamp() {
   return (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
 }
 function createBackup(sourceDirs) {
   const timestamp = createBackupTimestamp();
-  const backupPath = join3(BACKUPS_DIR, timestamp);
+  const backupPath = join2(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);
+    const targetPath = join2(backupPath, targetName);
     cpSync(sourceDir, targetPath, { recursive: true });
     targets.push(targetName);
   }
@@ -195,7 +155,7 @@ 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 backupPath = join2(BACKUPS_DIR, e.name);
     const contents = readdirSync(backupPath);
     return {
       timestamp: e.name,
@@ -205,14 +165,14 @@ function listBackups() {
   }).sort((a, b) => b.timestamp.localeCompare(a.timestamp));
 }
 function restoreBackup(timestamp, targetDirs) {
-  const backupPath = join3(BACKUPS_DIR, timestamp);
+  const backupPath = join2(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 sourcePath = join2(backupPath, entry.name);
     const targetPath = targetDirs[entry.name];
     if (!targetPath) continue;
     if (existsSync3(targetPath)) {
@@ -234,8 +194,10 @@ function cleanOldBackups(keepCount = 10) {
 }
 
 // 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";
+init_esm_shims();
+init_paths();
+import { existsSync as existsSync4, mkdirSync as mkdirSync2, readdirSync as readdirSync2, symlinkSync, unlinkSync, lstatSync, readlinkSync, rmSync as rmSync2, copyFileSync, chmodSync } from "fs";
+import { join as join3 } from "path";
 function removeTarget(targetPath) {
   const stats = lstatSync(targetPath);
   if (stats.isDirectory() && !stats.isSymbolicLink()) {
@@ -260,13 +222,14 @@ function planSync(runtime) {
   const plan = {
     runtime,
     skills: [],
-    commands: []
+    commands: [],
+    agents: []
   };
   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);
+      const sourcePath = join3(SKILLS_DIR, skill.name);
+      const targetPath = join3(targets.skills, skill.name);
       let status = "new";
       if (existsSync4(targetPath)) {
         if (isPanopticonSymlink(targetPath)) {
@@ -281,8 +244,8 @@ function planSync(runtime) {
   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);
+      const sourcePath = join3(COMMANDS_DIR, cmd.name);
+      const targetPath = join3(targets.commands, cmd.name);
       let status = "new";
       if (existsSync4(targetPath)) {
         if (isPanopticonSymlink(targetPath)) {
@@ -294,6 +257,22 @@ function planSync(runtime) {
       plan.commands.push({ name: cmd.name, sourcePath, targetPath, status });
     }
   }
+  if (existsSync4(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 (existsSync4(targetPath)) {
+        if (isPanopticonSymlink(targetPath)) {
+          status = "symlink";
+        } else {
+          status = "conflict";
+        }
+      }
+      plan.agents.push({ name: agent.name, sourcePath, targetPath, status });
+    }
+  }
   return plan;
 }
 function executeSync(runtime, options = {}) {
@@ -306,6 +285,7 @@ function executeSync(runtime, options = {}) {
   const targets = SYNC_TARGETS[runtime];
   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") {
@@ -344,10 +324,62 @@ function executeSync(runtime, options = {}) {
     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 (existsSync4(item.targetPath)) {
+      removeTarget(item.targetPath);
+    }
+    symlinkSync(item.sourcePath, item.targetPath);
+    result.created.push(item.name);
+  }
+  return result;
+}
+function planHooksSync() {
+  const hooks = [];
+  if (!existsSync4(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 (existsSync4(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}`);
@@ -368,6 +400,7 @@ var TrackerAuthError = class extends Error {
 };
 
 // src/lib/tracker/linear.ts
+init_esm_shims();
 import { LinearClient } from "@linear/sdk";
 var STATE_MAP = {
   backlog: "open",
@@ -577,6 +610,7 @@ var LinearTracker = class {
 };
 
 // src/lib/tracker/github.ts
+init_esm_shims();
 import { Octokit } from "@octokit/rest";
 var GitHubTracker = class {
   name = "github";
@@ -737,6 +771,7 @@ var GitHubTracker = class {
 };
 
 // src/lib/tracker/gitlab.ts
+init_esm_shims();
 var GitLabTracker = class {
   constructor(token, projectId) {
     this.token = token;
@@ -785,6 +820,385 @@ var GitLabTracker = class {
   }
 };
 
+// src/lib/tracker/factory.ts
+init_esm_shims();
+
+// src/lib/tracker/rally.ts
+init_esm_shims();
+import rally from "rally";
+var STATE_MAP2 = {
+  Defined: "open",
+  "In-Progress": "in_progress",
+  Completed: "closed",
+  Accepted: "closed"
+};
+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 = rally({
+      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;
+  }
+  async listIssues(filters) {
+    const query = {
+      type: "artifact",
+      // Query all artifact types
+      fetch: [
+        "FormattedID",
+        "Name",
+        "Description",
+        "ScheduleState",
+        "State",
+        // For Defects
+        "Tags",
+        "Owner",
+        "Priority",
+        "DueDate",
+        "CreationDate",
+        "LastUpdateDate",
+        "Parent",
+        "_type"
+      ],
+      limit: filters?.limit ?? 50,
+      query: this.buildQueryString(filters)
+    };
+    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");
+      }
+      throw error;
+    }
+  }
+  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 rallyState = this.reverseMapState(update.state);
+      if (artifact._type === "Defect") {
+        updatePayload.State = rallyState;
+      } else {
+        updatePayload.ScheduleState = 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
+  buildQueryString(filters) {
+    const conditions = [];
+    if (filters?.state && !filters.includeClosed) {
+      const rallyState = this.reverseMapState(filters.state);
+      conditions.push(`((ScheduleState = "${rallyState}") OR (State = "${rallyState}"))`);
+    }
+    if (!filters?.includeClosed) {
+      conditions.push('((ScheduleState != "Completed") AND (ScheduleState != "Accepted") AND (State != "Closed"))');
+    }
+    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}")`
+      );
+      conditions.push(`(${labelConditions.join(" AND ")})`);
+    }
+    if (filters?.query) {
+      conditions.push(`((Name contains "${filters.query}") OR (Description contains "${filters.query}"))`);
+    }
+    return conditions.length > 0 ? conditions.join(" AND ") : "";
+  }
+  normalizeIssue(rallyArtifact) {
+    const stateValue = rallyArtifact.ScheduleState || rallyArtifact.State || "Defined";
+    const state = this.mapState(stateValue);
+    const labels = [];
+    if (rallyArtifact.Tags && rallyArtifact.Tags._tagsNameArray) {
+      labels.push(...rallyArtifact.Tags._tagsNameArray);
+    }
+    const priority = rallyArtifact.Priority ? PRIORITY_MAP[rallyArtifact.Priority] ?? 2 : void 0;
+    const baseUrl = this.restApi.server.replace("/slm/webservice/", "");
+    const url = `${baseUrl}/#/detail/${rallyArtifact._type.toLowerCase()}/${rallyArtifact.ObjectID}`;
+    return {
+      id: rallyArtifact.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
+    };
+  }
+  mapState(rallyState) {
+    return STATE_MAP2[rallyState] ?? "open";
+  }
+  reverseMapState(state) {
+    switch (state) {
+      case "open":
+        return "Defined";
+      case "in_progress":
+        return "In-Progress";
+      case "closed":
+        return "Completed";
+      default:
+        return "Defined";
+    }
+  }
+  // Rally API wrapper methods
+  queryRally(queryConfig) {
+    return new Promise((resolve, reject) => {
+      this.restApi.query(queryConfig, (error, result) => {
+        if (error) {
+          reject(new Error(error.message || "Rally API query failed"));
+        } else {
+          resolve(result);
+        }
+      });
+    });
+  }
+  createRally(type, data) {
+    return new Promise((resolve, reject) => {
+      this.restApi.create({
+        type,
+        data,
+        fetch: ["FormattedID", "ObjectID", "_ref"]
+      }, (error, result) => {
+        if (error) {
+          reject(new Error(error.message || "Rally API create failed"));
+        } else {
+          resolve(result);
+        }
+      });
+    });
+  }
+  updateRally(type, ref, data) {
+    return new Promise((resolve, reject) => {
+      this.restApi.update({
+        type,
+        ref,
+        data,
+        fetch: ["FormattedID", "ObjectID"]
+      }, (error, result) => {
+        if (error) {
+          reject(new Error(error.message || "Rally API update failed"));
+        } else {
+          resolve(result);
+        }
+      });
+    });
+  }
+};
+
 // src/lib/tracker/factory.ts
 function createTracker(config) {
   switch (config.type) {
@@ -826,6 +1240,21 @@ function createTracker(config) {
       }
       return new GitLabTracker(token, config.projectId);
     }
+    case "rally": {
+      const apiKey = config.apiKeyEnv ? process.env[config.apiKeyEnv] : process.env.RALLY_API_KEY;
+      if (!apiKey) {
+        throw new TrackerAuthError(
+          "rally",
+          `API key not found. 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}`);
   }
@@ -858,9 +1287,10 @@ function getAllTrackers(trackersConfig) {
 }
 
 // src/lib/tracker/linking.ts
+init_esm_shims();
 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";
+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)}` };
@@ -892,7 +1322,7 @@ var LinkManager = class {
   storePath;
   store;
   constructor(storePath) {
-    this.storePath = storePath ?? join5(homedir3(), ".panopticon", "links.json");
+    this.storePath = storePath ?? join4(homedir2(), ".panopticon", "links.json");
     this.store = this.load();
   }
   load() {
@@ -908,7 +1338,7 @@ var LinkManager = class {
     return { version: 1, links: [] };
   }
   save() {
-    const dir = join5(this.storePath, "..");
+    const dir = join4(this.storePath, "..");
     if (!existsSync5(dir)) {
       mkdirSync3(dir, { recursive: true });
     }
@@ -998,31 +1428,10 @@ function getLinkManager() {
   return _linkManager;
 }
 
+// src/lib/tracker/index.ts
+init_esm_shims();
+
 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,
@@ -1039,6 +1448,8 @@ export {
   isPanopticonSymlink,
   planSync,
   executeSync,
+  planHooksSync,
+  syncHooks,
   NotImplementedError,
   IssueNotFoundError,
   TrackerAuthError,
@@ -1055,4 +1466,4 @@ export {
   LinkManager,
   getLinkManager
 };
-//# sourceMappingURL=chunk-J7JUNJGH.js.map
+//# sourceMappingURL=chunk-B2JBBOJN.js.map