specweave 2.2.3 → 3.0.0

package/plugins/specweave/lib/integrations/github/github-graphql-client.ts

@@ -1,193 +0,0 @@
-/**
- * GitHub GraphQL Client for Projects V2
- *
- * Wraps `gh api graphql` CLI calls for GitHub Projects V2 operations.
- * All calls use child_process.execFile for security (no shell interpolation).
- *
- * @module github-graphql-client
- */
-
-import { execFile } from 'child_process';
-
-interface ProjectField {
-  id: string;
-  name: string;
-  options?: Array<{ id: string; name: string }>;
-}
-
-interface GraphQLResponse {
-  data?: Record<string, unknown>;
-  errors?: Array<{ message: string; type?: string; path?: string[] }>;
-}
-
-export class GitHubGraphQLClient {
-  private token?: string;
-
-  constructor(token?: string) {
-    this.token = token;
-  }
-
-  /**
-   * Resolve an owner login (user or org) to a node ID.
-   * Tries user first, falls back to organization.
-   */
-  async getOwnerNodeId(login: string): Promise<string> {
-    // Try user query first (parameterized)
-    const userQuery = `query($login: String!) { user(login: $login) { id } }`;
-    const userResult = await this.executeGraphQL(userQuery, { login });
-
-    if (userResult.data?.user && (userResult.data.user as { id?: string }).id) {
-      return (userResult.data.user as { id: string }).id;
-    }
-
-    // Fallback to organization (parameterized)
-    const orgQuery = `query($login: String!) { organization(login: $login) { id } }`;
-    const orgResult = await this.executeGraphQL(orgQuery, { login });
-
-    if (orgResult.data?.organization && (orgResult.data.organization as { id?: string }).id) {
-      return (orgResult.data.organization as { id: string }).id;
-    }
-
-    throw new Error(`Could not resolve to a User or Organization with the login of '${login}'.`);
-  }
-
-  /**
-   * Create a new GitHub Projects V2 board.
-   */
-  async createProjectV2(ownerId: string, title: string): Promise<{ id: string; number: number }> {
-    const query = `mutation($ownerId: ID!, $title: String!) {
-      createProjectV2(input: { ownerId: $ownerId, title: $title }) {
-        projectV2 { id number }
-      }
-    }`;
-
-    const result = await this.executeGraphQL(query, { ownerId, title });
-    const project = (result.data?.createProjectV2 as { projectV2: { id: string; number: number } })?.projectV2;
-    return { id: project.id, number: project.number };
-  }
-
-  /**
-   * Add an issue (by node ID) to a Projects V2 board.
-   * Returns the project item ID. Idempotent.
-   */
-  async addProjectV2Item(projectId: string, contentId: string): Promise<string> {
-    const query = `mutation($projectId: ID!, $contentId: ID!) {
-      addProjectV2ItemById(input: { projectId: $projectId, contentId: $contentId }) {
-        item { id }
-      }
-    }`;
-
-    const result = await this.executeGraphQL(query, { projectId, contentId });
-    const item = (result.data?.addProjectV2ItemById as { item: { id: string } })?.item;
-    return item.id;
-  }
-
-  /**
-   * Update a field value on a Projects V2 item.
-   */
-  async updateItemFieldValue(
-    projectId: string,
-    itemId: string,
-    fieldId: string,
-    value: { singleSelectOptionId: string },
-  ): Promise<void> {
-    const query = `mutation($projectId: ID!, $itemId: ID!, $fieldId: ID!, $optionId: String!) {
-      updateProjectV2ItemFieldValue(input: {
-        projectId: $projectId,
-        itemId: $itemId,
-        fieldId: $fieldId,
-        value: { singleSelectOptionId: $optionId }
-      }) {
-        projectV2Item { id }
-      }
-    }`;
-
-    await this.executeGraphQL(query, {
-      projectId,
-      itemId,
-      fieldId,
-      optionId: value.singleSelectOptionId,
-    });
-  }
-
-  /**
-   * Get field definitions for a Projects V2 board.
-   */
-  async getProjectFields(projectId: string): Promise<ProjectField[]> {
-    const query = `query($nodeId: ID!) {
-      node(id: $nodeId) {
-        ... on ProjectV2 {
-          fields(first: 50) {
-            nodes {
-              ... on ProjectV2Field { id name dataType }
-              ... on ProjectV2SingleSelectField {
-                id name dataType
-                options { id name }
-              }
-            }
-          }
-        }
-      }
-    }`;
-
-    const result = await this.executeGraphQL(query, { nodeId: projectId });
-    const fields = (result.data?.node as { fields?: { nodes: Array<{
-      id: string;
-      name: string;
-      dataType: string;
-      options?: Array<{ id: string; name: string }>;
-    }> } })?.fields?.nodes || [];
-
-    return fields.map((f) => {
-      const field: ProjectField = { id: f.id, name: f.name };
-      if (f.options && f.options.length > 0) {
-        field.options = f.options;
-      }
-      return field;
-    });
-  }
-
-  /**
-   * Execute a GraphQL query via `gh api graphql`.
-   * All variables are passed via `-F` flags to prevent injection.
-   */
-  private executeGraphQL(query: string, variables: Record<string, string> = {}): Promise<GraphQLResponse> {
-    return new Promise((resolve, reject) => {
-      const args = ['api', 'graphql', '-f', `query=${query}`];
-
-      // Pass all variables as structured parameters via -F
-      for (const [key, value] of Object.entries(variables)) {
-        args.push('-F', `${key}=${value}`);
-      }
-
-      const opts: { env?: NodeJS.ProcessEnv } = {};
-
-      if (this.token) {
-        opts.env = { ...process.env, GH_TOKEN: this.token };
-      }
-
-      execFile('gh', args, opts, (err, stdout, stderr) => {
-        if (err) {
-          reject(new Error(stderr || err.message));
-          return;
-        }
-
-        let parsed: GraphQLResponse;
-        try {
-          parsed = JSON.parse(stdout);
-        } catch {
-          reject(new Error(`Failed to parse GraphQL response: ${stdout.slice(0, 200)}`));
-          return;
-        }
-
-        if (parsed.errors && parsed.errors.length > 0) {
-          const messages = parsed.errors.map((e) => e.message).join('; ');
-          reject(new Error(`GraphQL error: ${messages}`));
-          return;
-        }
-
-        resolve(parsed);
-      });
-    });
-  }
-}

package/plugins/specweave/lib/integrations/github/github-hierarchical-sync.js

@@ -1,190 +0,0 @@
-import {
-  isSimpleStrategy,
-  isFilteredStrategy,
-  isCustomStrategy
-} from "../../../../../src/core/types/sync-profile.js";
-import { execFileNoThrow } from "../../../../../src/utils/execFileNoThrow.js";
-import { getGitHubAuthFromProject } from "../../../../../src/utils/auth-helpers.js";
-function getGhEnv() {
-  const { token } = getGitHubAuthFromProject(process.cwd());
-  return token ? { ...process.env, GH_TOKEN: token } : process.env;
-}
-async function buildHierarchicalSearchQuery(containers) {
-  const parts = [];
-  for (const container of containers) {
-    parts.push(`repo:${container.id}`);
-    if (container.subOrganizations && container.subOrganizations.length > 0) {
-      console.warn(
-        `\u26A0\uFE0F  GitHub search doesn't support project board filtering directly.`
-      );
-      console.warn(
-        `   Boards will be ignored: ${container.subOrganizations.join(", ")}`
-      );
-    }
-  }
-  parts.push("is:issue");
-  const filters = containers[0]?.filters;
-  if (filters) {
-    const filterClauses = buildFilterClauses(filters);
-    parts.push(...filterClauses);
-  }
-  return parts.join(" ");
-}
-function buildFilterClauses(filters) {
-  const clauses = [];
-  if (filters.includeLabels && filters.includeLabels.length > 0) {
-    for (const label of filters.includeLabels) {
-      clauses.push(`label:"${label}"`);
-    }
-  }
-  if (filters.excludeLabels && filters.excludeLabels.length > 0) {
-    for (const label of filters.excludeLabels) {
-      clauses.push(`-label:"${label}"`);
-    }
-  }
-  if (filters.assignees && filters.assignees.length > 0) {
-    const assigneeQuery = filters.assignees.map((a) => `assignee:"${a}"`).join(" ");
-    clauses.push(assigneeQuery);
-  }
-  if (filters.statusCategories && filters.statusCategories.length > 0) {
-    const statuses = filters.statusCategories.map((s) => s.toLowerCase());
-    if (statuses.includes("open") || statuses.includes("to do") || statuses.includes("in progress")) {
-      clauses.push("is:open");
-    } else if (statuses.includes("closed") || statuses.includes("done")) {
-      clauses.push("is:closed");
-    }
-  }
-  if (filters.milestones && filters.milestones.length > 0) {
-    for (const milestone of filters.milestones) {
-      clauses.push(`milestone:"${milestone}"`);
-    }
-  }
-  return clauses;
-}
-function addTimeRangeFilter(query, timeRange) {
-  if (timeRange === "ALL") {
-    return query;
-  }
-  const { since, until } = calculateTimeRange(timeRange);
-  return `${query} created:${since}..${until}`;
-}
-function calculateTimeRange(timeRange) {
-  const now = /* @__PURE__ */ new Date();
-  const since = new Date(now);
-  switch (timeRange) {
-    case "1W":
-      since.setDate(now.getDate() - 7);
-      break;
-    case "2W":
-      since.setDate(now.getDate() - 14);
-      break;
-    case "1M":
-      since.setMonth(now.getMonth() - 1);
-      break;
-    case "3M":
-      since.setMonth(now.getMonth() - 3);
-      break;
-    case "6M":
-      since.setMonth(now.getMonth() - 6);
-      break;
-    case "1Y":
-      since.setFullYear(now.getFullYear() - 1);
-      break;
-    case "ALL":
-      return {
-        since: "1970-01-01",
-        until: now.toISOString().split("T")[0]
-      };
-  }
-  return {
-    since: since.toISOString().split("T")[0],
-    until: now.toISOString().split("T")[0]
-  };
-}
-async function fetchIssuesHierarchical(profile, timeRange = "1M") {
-  const config = profile.config;
-  if (isSimpleStrategy(profile)) {
-    return fetchIssuesSimple(config, timeRange);
-  }
-  if (isCustomStrategy(profile)) {
-    return fetchIssuesCustom(config, timeRange);
-  }
-  if (isFilteredStrategy(profile)) {
-    return fetchIssuesFiltered(config, timeRange);
-  }
-  console.warn("\u26A0\uFE0F  Unknown strategy, defaulting to simple");
-  return fetchIssuesSimple(config, timeRange);
-}
-async function fetchIssuesSimple(config, timeRange) {
-  const owner = config.owner;
-  const repo = config.repo;
-  if (!owner || !repo) {
-    throw new Error("Simple strategy requires owner and repo in config");
-  }
-  let query = `repo:${owner}/${repo} is:issue`;
-  query = addTimeRangeFilter(query, timeRange);
-  console.log("\u{1F50D} Fetching issues (SIMPLE strategy):", query);
-  return executeSearch(query);
-}
-async function fetchIssuesCustom(config, timeRange) {
-  const customQuery = config.customQuery;
-  if (!customQuery) {
-    throw new Error("Custom strategy requires customQuery in config");
-  }
-  const query = addTimeRangeFilter(customQuery, timeRange);
-  console.log("\u{1F50D} Fetching issues (CUSTOM strategy):", query);
-  return executeSearch(query);
-}
-async function fetchIssuesFiltered(config, timeRange) {
-  const containers = config.containers;
-  if (!containers || containers.length === 0) {
-    throw new Error("Filtered strategy requires containers array in config");
-  }
-  const baseQuery = await buildHierarchicalSearchQuery(containers);
-  const query = addTimeRangeFilter(baseQuery, timeRange);
-  console.log("\u{1F50D} Fetching issues (FILTERED strategy):", query);
-  return executeSearch(query);
-}
-async function executeSearch(query) {
-  const result = await execFileNoThrow("gh", [
-    "search",
-    "issues",
-    query,
-    "--json",
-    "number,title,body,state,url,labels,milestone,repository",
-    "--limit",
-    "1000"
-    // Max results
-  ], { env: getGhEnv() });
-  if (result.exitCode !== 0) {
-    throw new Error(`Failed to search issues (exit code ${result.exitCode}): ${result.stderr || result.stdout}`);
-  }
-  if (!result.stdout.trim()) {
-    return [];
-  }
-  const issues = JSON.parse(result.stdout);
-  return issues.map((issue) => ({
-    number: issue.number,
-    title: issue.title,
-    body: issue.body || "",
-    state: issue.state,
-    html_url: issue.url,
-    url: issue.url,
-    labels: issue.labels?.map((l) => l.name) || [],
-    milestone: issue.milestone ? {
-      number: issue.milestone.number,
-      title: issue.milestone.title,
-      description: issue.milestone.description,
-      state: issue.milestone.state
-    } : void 0,
-    repository: issue.repository ? {
-      owner: issue.repository.owner.login,
-      name: issue.repository.name,
-      full_name: issue.repository.full_name
-    } : void 0
-  }));
-}
-export {
-  buildHierarchicalSearchQuery,
-  fetchIssuesHierarchical
-};