@gh-symphony/cli 0.0.16 → 0.0.18

package/dist/chunk-62L6QQE6.js

@@ -0,0 +1,362 @@
+#!/usr/bin/env node
+
+// src/github/client.ts
+var DEFAULT_API_URL = "https://api.github.com/graphql";
+var REST_API_URL = "https://api.github.com";
+var GitHubApiError = class extends Error {
+  constructor(message, status) {
+    super(message);
+    this.status = status;
+    this.name = "GitHubApiError";
+  }
+};
+var GitHubScopeError = class extends GitHubApiError {
+  constructor(message, requiredScopes, currentScopes) {
+    super(message);
+    this.requiredScopes = requiredScopes;
+    this.currentScopes = currentScopes;
+    this.name = "GitHubScopeError";
+  }
+};
+function createClient(token, options) {
+  return {
+    token,
+    apiUrl: options?.apiUrl ?? DEFAULT_API_URL,
+    fetchImpl: options?.fetchImpl ?? fetch
+  };
+}
+async function validateToken(client) {
+  const restUrl = client.apiUrl.replace("/graphql", "");
+  const baseUrl = restUrl === client.apiUrl ? REST_API_URL : restUrl;
+  const response = await client.fetchImpl(`${baseUrl}/user`, {
+    headers: {
+      authorization: `Bearer ${client.token}`,
+      accept: "application/vnd.github+json"
+    }
+  });
+  if (!response.ok) {
+    if (response.status === 401) {
+      throw new GitHubApiError("Invalid token: authentication failed.", 401);
+    }
+    throw new GitHubApiError(
+      `GitHub API error: ${response.status} ${response.statusText}`,
+      response.status
+    );
+  }
+  const scopes = response.headers.get("x-oauth-scopes")?.split(",").map((s) => s.trim()).filter(Boolean) ?? [];
+  const user = await response.json();
+  return {
+    login: user.login,
+    name: user.name,
+    scopes
+  };
+}
+function checkRequiredScopes(scopes) {
+  const required = ["repo", "read:org", "project"];
+  const normalizedScopes = scopes.map((s) => s.toLowerCase());
+  const missing = required.filter((r) => !normalizedScopes.includes(r));
+  return { valid: missing.length === 0, missing };
+}
+async function listUserProjects(client) {
+  const data = await graphql(
+    client,
+    VIEWER_PROJECTS_QUERY
+  );
+  const projects = [];
+  for (const node of data.viewer.projectsV2?.nodes ?? []) {
+    if (!node) continue;
+    projects.push(
+      normalizeProjectSummary(node, {
+        login: data.viewer.login,
+        type: "User"
+      })
+    );
+  }
+  for (const orgNode of data.viewer.organizations?.nodes ?? []) {
+    if (!orgNode) continue;
+    for (const projNode of orgNode.projectsV2?.nodes ?? []) {
+      if (!projNode) continue;
+      projects.push(
+        normalizeProjectSummary(projNode, {
+          login: orgNode.login,
+          type: "Organization"
+        })
+      );
+    }
+  }
+  return projects;
+}
+function normalizeProjectSummary(node, owner) {
+  return {
+    id: node.id,
+    title: node.title,
+    shortDescription: node.shortDescription ?? "",
+    url: node.url,
+    openItemCount: node.items?.totalCount ?? 0,
+    owner
+  };
+}
+async function getProjectDetail(client, projectId) {
+  const data = await graphql(
+    client,
+    PROJECT_DETAIL_QUERY,
+    { projectId }
+  );
+  const project = data.node;
+  if (!project || project.__typename !== "ProjectV2") {
+    throw new GitHubApiError(`Project not found: ${projectId}`);
+  }
+  const statusFields = [];
+  const textFields = [];
+  for (const field of project.fields?.nodes ?? []) {
+    if (!field) continue;
+    if (field.__typename === "ProjectV2SingleSelectField") {
+      statusFields.push({
+        id: field.id,
+        name: field.name,
+        options: (field.options ?? []).map((opt) => ({
+          id: opt.id,
+          name: opt.name,
+          description: opt.description ?? null,
+          color: opt.color ?? null
+        }))
+      });
+    } else if (field.__typename === "ProjectV2Field" && field.dataType) {
+      textFields.push({
+        id: field.id,
+        name: field.name,
+        dataType: field.dataType
+      });
+    }
+  }
+  const repoMap = /* @__PURE__ */ new Map();
+  let cursor = null;
+  let hasMore = true;
+  for (const item of project.items?.nodes ?? []) {
+    const repo = item?.content?.repository;
+    if (!repo) continue;
+    const key = `${repo.owner.login}/${repo.name}`;
+    if (!repoMap.has(key)) {
+      repoMap.set(key, {
+        owner: repo.owner.login,
+        name: repo.name,
+        url: repo.url,
+        cloneUrl: repo.url.endsWith(".git") ? repo.url : `${repo.url}.git`
+      });
+    }
+  }
+  hasMore = project.items?.pageInfo?.hasNextPage ?? false;
+  cursor = project.items?.pageInfo?.endCursor ?? null;
+  while (hasMore && cursor) {
+    const pageData = await graphql(
+      client,
+      PROJECT_ITEMS_PAGE_QUERY,
+      { projectId, cursor }
+    );
+    const items = pageData.node?.items;
+    if (!items) break;
+    for (const item of items.nodes ?? []) {
+      const repo = item?.content?.repository;
+      if (!repo) continue;
+      const key = `${repo.owner.login}/${repo.name}`;
+      if (!repoMap.has(key)) {
+        repoMap.set(key, {
+          owner: repo.owner.login,
+          name: repo.name,
+          url: repo.url,
+          cloneUrl: repo.url.endsWith(".git") ? repo.url : `${repo.url}.git`
+        });
+      }
+    }
+    hasMore = items.pageInfo?.hasNextPage ?? false;
+    cursor = items.pageInfo?.endCursor ?? null;
+  }
+  return {
+    id: project.id,
+    title: project.title,
+    url: project.url,
+    statusFields,
+    textFields,
+    linkedRepositories: [...repoMap.values()]
+  };
+}
+async function graphql(client, query, variables) {
+  const response = await client.fetchImpl(client.apiUrl, {
+    method: "POST",
+    headers: {
+      "content-type": "application/json",
+      authorization: `Bearer ${client.token}`
+    },
+    body: JSON.stringify({ query, variables })
+  });
+  if (!response.ok) {
+    const text = await response.text().catch(() => "");
+    throw new GitHubApiError(
+      `GitHub GraphQL request failed: ${response.status} ${response.statusText}. ${text}`,
+      response.status
+    );
+  }
+  const payload = await response.json();
+  if (payload.errors?.length) {
+    const scopeMessages = payload.errors.map((e) => e.message).filter((m) => m.includes("has not been granted the required scopes"));
+    if (scopeMessages.length > 0) {
+      const requiredScopes = /* @__PURE__ */ new Set();
+      let currentScopes = [];
+      for (const msg of scopeMessages) {
+        for (const match of msg.matchAll(
+          /requires one of the following scopes: \['([^']+)'\]/g
+        )) {
+          requiredScopes.add(match[1]);
+        }
+        if (currentScopes.length === 0) {
+          const currMatch = /has only been granted the: \[([^\]]+)\]/.exec(msg);
+          if (currMatch) {
+            currentScopes = currMatch[1].split(",").map((s) => s.trim().replace(/'/g, "")).filter(Boolean);
+          }
+        }
+      }
+      throw new GitHubScopeError(
+        "Token is missing required GitHub scopes.",
+        [...requiredScopes],
+        currentScopes
+      );
+    }
+    throw new GitHubApiError(
+      `GraphQL errors: ${payload.errors.map((e) => e.message).join("; ")}`
+    );
+  }
+  if (!payload.data) {
+    throw new GitHubApiError("GraphQL response missing data.");
+  }
+  return payload.data;
+}
+var VIEWER_PROJECTS_QUERY = `
+  query ViewerProjects {
+    viewer {
+      login
+      projectsV2(first: 50) {
+        nodes {
+          id
+          title
+          shortDescription
+          url
+          items { totalCount }
+        }
+      }
+      organizations(first: 20) {
+        nodes {
+          login
+          projectsV2(first: 50) {
+            nodes {
+              id
+              title
+              shortDescription
+              url
+              items { totalCount }
+            }
+          }
+        }
+      }
+    }
+  }
+`;
+var PROJECT_DETAIL_QUERY = `
+  query ProjectDetail($projectId: ID!) {
+    node(id: $projectId) {
+      __typename
+      ... on ProjectV2 {
+        id
+        title
+        url
+        fields(first: 50) {
+          nodes {
+            __typename
+            ... on ProjectV2SingleSelectField {
+              id
+              name
+              options {
+                id
+                name
+                description
+                color
+              }
+            }
+            ... on ProjectV2Field {
+              id
+              name
+              dataType
+            }
+          }
+        }
+        items(first: 100) {
+          nodes {
+            content {
+              __typename
+              ... on Issue {
+                repository {
+                  name
+                  url
+                  owner { login }
+                }
+              }
+              ... on PullRequest {
+                repository {
+                  name
+                  url
+                  owner { login }
+                }
+              }
+            }
+          }
+          pageInfo {
+            endCursor
+            hasNextPage
+          }
+        }
+      }
+    }
+  }
+`;
+var PROJECT_ITEMS_PAGE_QUERY = `
+  query ProjectItemsPage($projectId: ID!, $cursor: String) {
+    node(id: $projectId) {
+      ... on ProjectV2 {
+        items(first: 100, after: $cursor) {
+          nodes {
+            content {
+              __typename
+              ... on Issue {
+                repository {
+                  name
+                  url
+                  owner { login }
+                }
+              }
+              ... on PullRequest {
+                repository {
+                  name
+                  url
+                  owner { login }
+                }
+              }
+            }
+          }
+          pageInfo {
+            endCursor
+            hasNextPage
+          }
+        }
+      }
+    }
+  }
+`;
+
+export {
+  GitHubApiError,
+  GitHubScopeError,
+  createClient,
+  validateToken,
+  checkRequiredScopes,
+  listUserProjects,
+  getProjectDetail
+};

package/dist/{chunk-JO3AXHQI.js → chunk-7UBUBSMH.js}

@@ -2,7 +2,7 @@
 
 // src/github/gh-auth.ts
 import { execFileSync, spawnSync } from "child_process";
-var REQUIRED_SCOPES = ["repo", "read:org", "project"];
+var REQUIRED_GH_SCOPES = ["repo", "read:org", "project"];
 var GhAuthError = class extends Error {
   constructor(code, message) {
     super(message);
@@ -47,7 +47,7 @@ function checkGhScopes(opts) {
     return { valid: true, missing: [], scopes: [] };
   }
   const normalized = scopes.map((scope) => scope.toLowerCase());
-  const missing = REQUIRED_SCOPES.filter(
+  const missing = REQUIRED_GH_SCOPES.filter(
     (scope) => !normalized.includes(scope)
   );
   return {
@@ -124,7 +124,11 @@ function parseScopes(output) {
 }
 
 export {
+  REQUIRED_GH_SCOPES,
   GhAuthError,
+  checkGhInstalled,
+  checkGhAuthenticated,
+  checkGhScopes,
   getGhToken,
   ensureGhAuth
 };

package/dist/chunk-C7G7RJ4G.js

@@ -0,0 +1,146 @@
+#!/usr/bin/env node
+import {
+  loadGlobalConfig,
+  loadProjectConfig
+} from "./chunk-ROGRTUFI.js";
+
+// src/project-selection.ts
+import * as p from "@clack/prompts";
+function isInteractiveTerminal() {
+  return process.stdin.isTTY === true && process.stdout.isTTY === true;
+}
+function explicitProjectRequiredMessage() {
+  return "Multiple projects are configured. Re-run with --project-id in non-interactive environments.\n";
+}
+async function inspectManagedProjectSelection(input) {
+  if (input.requestedProjectId) {
+    const projectConfig = await loadProjectConfig(
+      input.configDir,
+      input.requestedProjectId
+    );
+    if (!projectConfig) {
+      return {
+        kind: "requested_project_missing",
+        projectId: input.requestedProjectId,
+        message: `Project "${input.requestedProjectId}" is not configured. Run 'gh-symphony project add' or choose an existing project.`
+      };
+    }
+    return {
+      kind: "resolved",
+      projectId: input.requestedProjectId,
+      projectConfig
+    };
+  }
+  const global = await loadGlobalConfig(input.configDir);
+  if (!global) {
+    return {
+      kind: "missing_global_config",
+      message: "No CLI configuration found. Run 'gh-symphony project add' first."
+    };
+  }
+  const projectIds = global.projects ?? [];
+  if (projectIds.length === 0) {
+    return {
+      kind: "no_projects",
+      message: "No managed projects are configured. Run 'gh-symphony project add' first."
+    };
+  }
+  if (projectIds.length > 1 && !isInteractiveTerminal()) {
+    return {
+      kind: "multiple_projects_require_selection",
+      message: explicitProjectRequiredMessage().trimEnd()
+    };
+  }
+  if (global.activeProject) {
+    const projectConfig = await loadProjectConfig(
+      input.configDir,
+      global.activeProject
+    );
+    if (!projectConfig) {
+      return {
+        kind: "active_project_missing",
+        projectId: global.activeProject,
+        message: `Active project "${global.activeProject}" is configured in config.json but its project config is missing. Re-run 'gh-symphony project add' or 'gh-symphony project switch'.`
+      };
+    }
+    return {
+      kind: "resolved",
+      projectId: global.activeProject,
+      projectConfig
+    };
+  }
+  if (projectIds.length === 1) {
+    const projectId = projectIds[0];
+    const projectConfig = await loadProjectConfig(input.configDir, projectId);
+    if (!projectConfig) {
+      return {
+        kind: "configured_project_missing",
+        projectId,
+        message: `Configured project "${projectId}" is missing its project config file. Re-run 'gh-symphony project add'.`
+      };
+    }
+    return {
+      kind: "resolved",
+      projectId,
+      projectConfig
+    };
+  }
+  return {
+    kind: "multiple_projects_require_selection",
+    message: "Multiple projects are configured and no active project is set. Run 'gh-symphony project switch' or re-run with --project-id."
+  };
+}
+async function resolveManagedProjectConfig(input) {
+  if (input.requestedProjectId) {
+    return loadProjectConfig(input.configDir, input.requestedProjectId);
+  }
+  const global = await loadGlobalConfig(input.configDir);
+  const projectIds = global?.projects ?? [];
+  if (projectIds.length === 0) {
+    return null;
+  }
+  if (projectIds.length === 1) {
+    return loadProjectConfig(input.configDir, projectIds[0]);
+  }
+  if (!isInteractiveTerminal()) {
+    process.stderr.write(explicitProjectRequiredMessage());
+    process.exitCode = 1;
+    return null;
+  }
+  const projects = await Promise.all(
+    projectIds.map(async (projectId) => ({
+      projectId,
+      config: await loadProjectConfig(input.configDir, projectId)
+    }))
+  );
+  const selected = await p.select({
+    message: "Select a project:",
+    options: projects.map(({ projectId, config }) => ({
+      value: projectId,
+      label: config?.displayName ?? config?.slug ?? projectId,
+      hint: projectId === global?.activeProject ? "current" : config && config.displayName && config.displayName !== projectId ? projectId : void 0
+    })),
+    maxItems: 10
+  });
+  if (p.isCancel(selected)) {
+    p.cancel("Cancelled.");
+    process.exitCode = 130;
+    return null;
+  }
+  return loadProjectConfig(input.configDir, selected);
+}
+function handleMissingManagedProjectConfig() {
+  if (process.exitCode) {
+    return;
+  }
+  process.stderr.write(
+    "No project configured. Run 'gh-symphony project add' first.\n"
+  );
+  process.exitCode = 1;
+}
+
+export {
+  inspectManagedProjectSelection,
+  resolveManagedProjectConfig,
+  handleMissingManagedProjectConfig
+};