panopticon-cli 0.4.32 → 0.5.0

package/dist/chunk-CFCUOV3Q.js

@@ -0,0 +1,669 @@
+import {
+  __esm,
+  init_esm_shims
+} from "./chunk-ZHC57RCV.js";
+
+// src/lib/tracker/rally-api.ts
+var RallyRestApi;
+var init_rally_api = __esm({
+  "src/lib/tracker/rally-api.ts"() {
+    "use strict";
+    init_esm_shims();
+    RallyRestApi = class {
+      apiKey;
+      server;
+      customHeaders;
+      constructor(config) {
+        this.apiKey = config.apiKey;
+        this.server = config.server || "https://rally1.rallydev.com";
+        this.customHeaders = config.requestOptions?.headers || {};
+      }
+      /**
+       * Query Rally artifacts
+       */
+      async query(config) {
+        const params = new URLSearchParams();
+        if (config.query) {
+          params.set("query", config.query);
+        }
+        if (config.fetch && config.fetch.length > 0) {
+          params.set("fetch", config.fetch.join(","));
+        }
+        if (config.limit !== void 0) {
+          params.set("pagesize", String(config.limit));
+        }
+        if (config.workspace) {
+          params.set("workspace", config.workspace);
+        }
+        if (config.project) {
+          params.set("project", config.project);
+          if (config.projectScopeDown) {
+            params.set("projectScopeDown", "true");
+          }
+        }
+        if (config.order) {
+          params.set("order", config.order);
+        }
+        const url = `${this.server}/slm/webservice/v2.0/${config.type}?${params.toString()}`;
+        const response = await fetch(url, {
+          method: "GET",
+          headers: {
+            "ZSESSIONID": this.apiKey,
+            "Content-Type": "application/json",
+            ...this.customHeaders
+          }
+        });
+        if (!response.ok) {
+          if (response.status === 401) {
+            throw new Error("Unauthorized: Invalid API key or insufficient permissions");
+          }
+          throw new Error(`Rally API query failed: ${response.status} ${response.statusText}`);
+        }
+        const result = await response.json();
+        if (result.QueryResult.Errors && result.QueryResult.Errors.length > 0) {
+          const errorDetail = result.QueryResult.Errors.join(", ");
+          const queryDetail = config.query ? ` (Query: ${config.query})` : "";
+          if (process.env.DEBUG?.includes("rally")) {
+            console.error("[Rally WSAPI] Query failed:", { query: config.query, errors: result.QueryResult.Errors });
+          }
+          throw new Error(`Rally API query failed: ${errorDetail}${queryDetail}`);
+        }
+        return result;
+      }
+      /**
+       * Create a Rally object
+       */
+      async create(config) {
+        const url = `${this.server}/slm/webservice/v2.0/${config.type}/create`;
+        const body = {
+          [config.type]: config.data
+        };
+        const params = new URLSearchParams();
+        if (config.fetch && config.fetch.length > 0) {
+          params.set("fetch", config.fetch.join(","));
+        }
+        const finalUrl = params.toString() ? `${url}?${params.toString()}` : url;
+        const response = await fetch(finalUrl, {
+          method: "POST",
+          headers: {
+            "ZSESSIONID": this.apiKey,
+            "Content-Type": "application/json",
+            ...this.customHeaders
+          },
+          body: JSON.stringify(body)
+        });
+        if (!response.ok) {
+          throw new Error(`Rally API create failed: ${response.status} ${response.statusText}`);
+        }
+        const result = await response.json();
+        if (result.CreateResult.Errors && result.CreateResult.Errors.length > 0) {
+          throw new Error(`Rally API create failed: ${result.CreateResult.Errors.join(", ")}`);
+        }
+        return result;
+      }
+      /**
+       * Update a Rally object
+       */
+      async update(config) {
+        const objectId = config.ref.split("/").pop();
+        const url = `${this.server}/slm/webservice/v2.0/${config.type}/${objectId}`;
+        const body = {
+          [config.type]: config.data
+        };
+        const params = new URLSearchParams();
+        if (config.fetch && config.fetch.length > 0) {
+          params.set("fetch", config.fetch.join(","));
+        }
+        const finalUrl = params.toString() ? `${url}?${params.toString()}` : url;
+        const response = await fetch(finalUrl, {
+          method: "POST",
+          headers: {
+            "ZSESSIONID": this.apiKey,
+            "Content-Type": "application/json",
+            ...this.customHeaders
+          },
+          body: JSON.stringify(body)
+        });
+        if (!response.ok) {
+          throw new Error(`Rally API update failed: ${response.status} ${response.statusText}`);
+        }
+        const result = await response.json();
+        if (result.OperationResult.Errors && result.OperationResult.Errors.length > 0) {
+          throw new Error(`Rally API update failed: ${result.OperationResult.Errors.join(", ")}`);
+        }
+        return result;
+      }
+    };
+  }
+});
+
+// src/lib/tracker/interface.ts
+var NotImplementedError, IssueNotFoundError, TrackerAuthError;
+var init_interface = __esm({
+  "src/lib/tracker/interface.ts"() {
+    "use strict";
+    init_esm_shims();
+    NotImplementedError = class extends Error {
+      constructor(feature) {
+        super(`Not implemented: ${feature}`);
+        this.name = "NotImplementedError";
+      }
+    };
+    IssueNotFoundError = class extends Error {
+      constructor(id, tracker) {
+        super(`Issue not found: ${id} (tracker: ${tracker})`);
+        this.name = "IssueNotFoundError";
+      }
+    };
+    TrackerAuthError = class extends Error {
+      constructor(tracker, message) {
+        super(`Authentication failed for ${tracker}: ${message}`);
+        this.name = "TrackerAuthError";
+      }
+    };
+  }
+});
+
+// src/lib/tracker/rally.ts
+var STATE_MAP, QUERYABLE_TYPES, FETCH_FIELDS, PRIORITY_MAP, REVERSE_PRIORITY_MAP, RallyTracker;
+var init_rally = __esm({
+  "src/lib/tracker/rally.ts"() {
+    init_esm_shims();
+    init_rally_api();
+    init_interface();
+    STATE_MAP = {
+      // User Stories (ScheduleState)
+      "New": "open",
+      "Idea": "open",
+      "Defined": "open",
+      "In-Progress": "in_progress",
+      "Completed": "closed",
+      "Accepted": "closed",
+      // Defects (State)
+      "Submitted": "open",
+      "Open": "in_progress",
+      // "Open" defects are actively being worked
+      "Fixed": "closed",
+      "Closed": "closed",
+      // Features / PortfolioItems (State)
+      "Discovering": "open",
+      "Developing": "in_progress",
+      "Done": "closed"
+    };
+    QUERYABLE_TYPES = [
+      { type: "hierarchicalrequirement", stateField: "ScheduleState", closedStates: ["Completed", "Accepted"] },
+      { type: "defect", stateField: "State", closedStates: ["Closed"] },
+      { type: "task", stateField: "State", closedStates: ["Completed"] },
+      { type: "portfolioitem/feature", stateField: "State", closedStates: ["Done"] }
+    ];
+    FETCH_FIELDS = [
+      "ObjectID",
+      "FormattedID",
+      "Name",
+      "Description",
+      "ScheduleState",
+      "State",
+      "Tags",
+      "Owner",
+      "Priority",
+      "DueDate",
+      "CreationDate",
+      "LastUpdateDate",
+      "Parent",
+      "PortfolioItem",
+      "_type"
+    ];
+    PRIORITY_MAP = {
+      "Resolve Immediately": 0,
+      High: 1,
+      Normal: 2,
+      Low: 3
+    };
+    REVERSE_PRIORITY_MAP = {
+      0: "Resolve Immediately",
+      1: "High",
+      2: "Normal",
+      3: "Low",
+      4: "Low"
+    };
+    RallyTracker = class {
+      name = "rally";
+      restApi;
+      workspace;
+      project;
+      constructor(config) {
+        if (!config.apiKey) {
+          throw new TrackerAuthError("rally", "API key is required");
+        }
+        this.restApi = new RallyRestApi({
+          apiKey: config.apiKey,
+          server: config.server || "https://rally1.rallydev.com",
+          requestOptions: {
+            headers: {
+              "X-RallyIntegrationType": "Panopticon",
+              "X-RallyIntegrationName": "Panopticon CLI",
+              "X-RallyIntegrationVendor": "Mind Your Now",
+              "X-RallyIntegrationVersion": "0.2.0"
+            }
+          }
+        });
+        this.workspace = config.workspace;
+        this.project = config.project;
+      }
+      /**
+       * List issues by querying each artifact type separately and merging results.
+       *
+       * Rally WSAPI cannot apply ScheduleState filters across the generic Artifact
+       * endpoint because not all subtypes have that field. We query each type with
+       * its own state field, then merge and sort. (PAN-168)
+       */
+      async listIssues(filters) {
+        if (process.env.DEBUG?.includes("rally")) {
+          console.debug("[Rally] Query filters:", JSON.stringify(filters));
+        }
+        const limit = filters?.limit ?? 50;
+        let projectObjectId;
+        if (this.project) {
+          const match = this.project.match(/\/project\/(\d+)/);
+          if (match) projectObjectId = match[1];
+        }
+        const queries = QUERYABLE_TYPES.map(async (artifactType) => {
+          const queryString = this.buildQueryStringForType(filters, artifactType, projectObjectId);
+          if (process.env.DEBUG?.includes("rally")) {
+            console.debug(`[Rally] ${artifactType.type} query:`, queryString);
+          }
+          const query = {
+            type: artifactType.type,
+            fetch: FETCH_FIELDS,
+            limit,
+            query: queryString
+          };
+          if (this.workspace) {
+            query.workspace = this.workspace;
+          }
+          if (this.project) {
+            query.project = this.project;
+            query.projectScopeDown = true;
+          }
+          try {
+            const result = await this.queryRally(query);
+            return result.Results.map((artifact) => this.normalizeIssue(artifact));
+          } catch (error) {
+            if (error.message?.includes("Unauthorized") || error.message?.includes("401")) {
+              throw new TrackerAuthError("rally", "Invalid API key or insufficient permissions");
+            }
+            if (process.env.DEBUG?.includes("rally")) {
+              console.debug(`[Rally] Failed to query ${artifactType.type}:`, error.message);
+            }
+            return [];
+          }
+        });
+        const results = await Promise.all(queries);
+        const allIssues = results.flat();
+        allIssues.sort(
+          (a, b) => new Date(b.updatedAt).getTime() - new Date(a.updatedAt).getTime()
+        );
+        return allIssues.slice(0, limit);
+      }
+      async getIssue(id) {
+        try {
+          const query = {
+            type: "artifact",
+            fetch: [
+              "FormattedID",
+              "Name",
+              "Description",
+              "ScheduleState",
+              "State",
+              "Tags",
+              "Owner",
+              "Priority",
+              "DueDate",
+              "CreationDate",
+              "LastUpdateDate",
+              "Parent",
+              "_type"
+            ],
+            query: `(FormattedID = "${id}")`
+          };
+          if (this.workspace) {
+            query.workspace = this.workspace;
+          }
+          const result = await this.queryRally(query);
+          if (!result.Results || result.Results.length === 0) {
+            throw new IssueNotFoundError(id, "rally");
+          }
+          return this.normalizeIssue(result.Results[0]);
+        } catch (error) {
+          if (error instanceof IssueNotFoundError) throw error;
+          throw new IssueNotFoundError(id, "rally");
+        }
+      }
+      async updateIssue(id, update) {
+        const issue = await this.getIssue(id);
+        const query = {
+          type: "artifact",
+          fetch: ["ObjectID", "_ref", "_type"],
+          query: `(FormattedID = "${id}")`
+        };
+        if (this.workspace) {
+          query.workspace = this.workspace;
+        }
+        const result = await this.queryRally(query);
+        if (!result.Results || result.Results.length === 0) {
+          throw new IssueNotFoundError(id, "rally");
+        }
+        const artifact = result.Results[0];
+        const updatePayload = {};
+        if (update.title !== void 0) {
+          updatePayload.Name = update.title;
+        }
+        if (update.description !== void 0) {
+          updatePayload.Description = update.description;
+        }
+        if (update.state !== void 0) {
+          const artifactType = (artifact._type || "").toLowerCase();
+          const kind = artifactType.startsWith("portfolioitem") ? "feature" : artifactType === "defect" ? "defect" : "story";
+          const rallyState = this.reverseMapState(update.state, kind);
+          if (kind === "story") {
+            updatePayload.ScheduleState = rallyState;
+          } else {
+            updatePayload.State = rallyState;
+          }
+        }
+        if (update.priority !== void 0) {
+          updatePayload.Priority = REVERSE_PRIORITY_MAP[update.priority] || "Normal";
+        }
+        if (update.dueDate !== void 0) {
+          updatePayload.DueDate = update.dueDate;
+        }
+        if (Object.keys(updatePayload).length > 0) {
+          await this.updateRally(artifact._type.toLowerCase(), artifact._ref, updatePayload);
+        }
+        return this.getIssue(id);
+      }
+      async createIssue(newIssue) {
+        if (!this.project && !newIssue.team) {
+          throw new Error("Project is required to create an issue. Set it in config or provide team field.");
+        }
+        const project = newIssue.team || this.project;
+        const createPayload = {
+          Name: newIssue.title,
+          Description: newIssue.description || "",
+          Project: project
+        };
+        if (newIssue.priority !== void 0) {
+          createPayload.Priority = REVERSE_PRIORITY_MAP[newIssue.priority] || "Normal";
+        }
+        if (newIssue.dueDate) {
+          createPayload.DueDate = newIssue.dueDate;
+        }
+        if (this.workspace) {
+          createPayload.Workspace = this.workspace;
+        }
+        const result = await this.createRally("hierarchicalrequirement", createPayload);
+        return this.getIssue(result.Object.FormattedID);
+      }
+      async getComments(issueId) {
+        const issue = await this.getIssue(issueId);
+        const query = {
+          type: "artifact",
+          fetch: ["ObjectID", "_ref", "Discussion"],
+          query: `(FormattedID = "${issueId}")`
+        };
+        if (this.workspace) {
+          query.workspace = this.workspace;
+        }
+        const result = await this.queryRally(query);
+        if (!result.Results || result.Results.length === 0) {
+          return [];
+        }
+        const artifact = result.Results[0];
+        if (!artifact.Discussion) {
+          return [];
+        }
+        const postsQuery = {
+          type: "conversationpost",
+          fetch: ["ObjectID", "Text", "User", "CreationDate", "PostNumber"],
+          query: `(Discussion = "${artifact.Discussion._ref}")`,
+          order: "PostNumber"
+        };
+        const postsResult = await this.queryRally(postsQuery);
+        return (postsResult.Results || []).map((post) => ({
+          id: post.ObjectID,
+          issueId,
+          body: post.Text || "",
+          author: post.User?._refObjectName || "Unknown",
+          createdAt: post.CreationDate,
+          updatedAt: post.CreationDate
+          // Rally doesn't track comment updates separately
+        }));
+      }
+      async addComment(issueId, body) {
+        const query = {
+          type: "artifact",
+          fetch: ["ObjectID", "_ref", "Discussion"],
+          query: `(FormattedID = "${issueId}")`
+        };
+        if (this.workspace) {
+          query.workspace = this.workspace;
+        }
+        const result = await this.queryRally(query);
+        if (!result.Results || result.Results.length === 0) {
+          throw new IssueNotFoundError(issueId, "rally");
+        }
+        const artifact = result.Results[0];
+        let discussionRef = artifact.Discussion?._ref;
+        if (!discussionRef) {
+          const discussionResult = await this.createRally("conversationpost", {
+            Artifact: artifact._ref,
+            Text: body
+          });
+          return {
+            id: discussionResult.Object.ObjectID,
+            issueId,
+            body,
+            author: "Panopticon",
+            createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+            updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+          };
+        }
+        const postResult = await this.createRally("conversationpost", {
+          Artifact: artifact._ref,
+          Text: body
+        });
+        return {
+          id: postResult.Object.ObjectID,
+          issueId,
+          body,
+          author: "Panopticon",
+          createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+          updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+        };
+      }
+      async transitionIssue(id, state) {
+        await this.updateIssue(id, { state });
+      }
+      async linkPR(issueId, prUrl) {
+        await this.addComment(issueId, `Linked Pull Request: ${prUrl}`);
+      }
+      // Private helper methods
+      /**
+       * Build a Rally WSAPI query string for a specific artifact type.
+       *
+       * Each artifact type has its own state field:
+       *   - HierarchicalRequirement: ScheduleState (Defined, In-Progress, Completed, Accepted)
+       *   - Defect: State (Submitted, Open, Fixed, Closed)
+       *   - Task: State (Defined, In-Progress, Completed)
+       *
+       * Rally WSAPI v2.0 requires binary-nested AND/OR with outer parentheses.
+       * (PAN-166, PAN-168)
+       */
+      buildQueryStringForType(filters, artifactType, projectObjectId) {
+        const conditions = [];
+        if (projectObjectId) {
+          conditions.push(`(Project.ObjectID = "${projectObjectId}")`);
+        }
+        if (filters?.state && !filters.includeClosed) {
+          const kind = artifactType.type.startsWith("portfolioitem") ? "feature" : artifactType.type === "defect" ? "defect" : "story";
+          const rallyState = this.reverseMapState(filters.state, kind);
+          conditions.push(`(${artifactType.stateField} = "${rallyState}")`);
+        }
+        if (!filters?.includeClosed) {
+          const closedConditions = artifactType.closedStates.map(
+            (state) => `(${artifactType.stateField} != "${state}")`
+          );
+          const closedExpr = closedConditions.reduce(
+            (acc, cond) => acc ? `(${acc} AND ${cond})` : cond,
+            ""
+          );
+          conditions.push(closedExpr);
+        }
+        if (filters?.assignee) {
+          conditions.push(`(Owner.Name contains "${filters.assignee}")`);
+        }
+        if (filters?.labels && filters.labels.length > 0) {
+          const labelConditions = filters.labels.map(
+            (label) => `(Tags.Name contains "${label}")`
+          );
+          const labelExpr = labelConditions.reduce((acc, cond) => acc ? `(${acc} AND ${cond})` : cond, "");
+          conditions.push(labelExpr);
+        }
+        if (filters?.query) {
+          conditions.push(`((Name contains "${filters.query}") OR (Description contains "${filters.query}"))`);
+        }
+        return conditions.reduce((acc, cond) => acc ? `(${acc} AND ${cond})` : cond, "");
+      }
+      normalizeIssue(rallyArtifact) {
+        const rawStateValue = rallyArtifact.ScheduleState || rallyArtifact.State || "Defined";
+        const stateValue = typeof rawStateValue === "object" && rawStateValue !== null ? rawStateValue.Name || rawStateValue._refObjectName || "Defined" : rawStateValue;
+        const state = this.mapState(stateValue);
+        const labels = [];
+        if (rallyArtifact.Tags && rallyArtifact.Tags._tagsNameArray) {
+          for (const tag of rallyArtifact.Tags._tagsNameArray) {
+            if (typeof tag === "string") {
+              labels.push(tag);
+            } else if (tag?.Name) {
+              labels.push(tag.Name);
+            }
+          }
+        }
+        const priority = rallyArtifact.Priority ? PRIORITY_MAP[rallyArtifact.Priority] ?? 2 : void 0;
+        const objectId = rallyArtifact.ObjectID || rallyArtifact.FormattedID;
+        const artifactType = rallyArtifact._type || "artifact";
+        const baseUrl = this.restApi.server.replace("/slm/webservice/", "");
+        const url = `${baseUrl}/#/detail/${artifactType.toLowerCase()}/${objectId}`;
+        let parentRef;
+        if (rallyArtifact.PortfolioItem) {
+          if (rallyArtifact.PortfolioItem.FormattedID) {
+            parentRef = rallyArtifact.PortfolioItem.FormattedID;
+          } else if (rallyArtifact.PortfolioItem._refObjectName) {
+            parentRef = rallyArtifact.PortfolioItem._refObjectName;
+          }
+        } else if (rallyArtifact.Parent) {
+          if (rallyArtifact.Parent.FormattedID) {
+            parentRef = rallyArtifact.Parent.FormattedID;
+          } else if (rallyArtifact.Parent._refObjectName) {
+            parentRef = rallyArtifact.Parent._refObjectName;
+          }
+        }
+        return {
+          id: String(objectId),
+          ref: rallyArtifact.FormattedID,
+          title: rallyArtifact.Name || "",
+          description: rallyArtifact.Description || "",
+          state,
+          labels,
+          assignee: rallyArtifact.Owner?._refObjectName,
+          url,
+          tracker: "rally",
+          priority,
+          dueDate: rallyArtifact.DueDate,
+          createdAt: rallyArtifact.CreationDate,
+          updatedAt: rallyArtifact.LastUpdateDate,
+          parentRef,
+          artifactType,
+          rawState: stateValue
+        };
+      }
+      mapState(rallyState) {
+        return STATE_MAP[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
+        };
+      }
+    };
+  }
+});
+
+export {
+  NotImplementedError,
+  IssueNotFoundError,
+  TrackerAuthError,
+  init_interface,
+  RallyTracker,
+  init_rally
+};
+//# sourceMappingURL=chunk-CFCUOV3Q.js.map