@chemx/starter-kit 26.9.9-786 → 26.9.11-481

package/cli/audit/social-http.js

@@ -0,0 +1,222 @@
+import {
+  DISCUSSION_CATEGORY,
+  DISCUSSION_CATEGORY_SLUG
+} from './social-constants.js';
+
+export const findMatchedCategory = (categories, categoryName) => {
+  const exactName = categories.find((c) => c.name === categoryName);
+  if (exactName) return exactName;
+
+  const exactSlug = categories.find((c) => c.slug === categoryName);
+  if (exactSlug) return exactSlug;
+
+  const defaultSlug = categories.find((c) => c.slug === DISCUSSION_CATEGORY_SLUG);
+  if (defaultSlug) return defaultSlug;
+
+  const targetLower = categoryName.toLowerCase();
+  const lowerName = categories.find((c) => c.name.toLowerCase() === targetLower);
+  if (lowerName) return lowerName;
+
+  const lowerSlug = categories.find((c) => c.slug.toLowerCase() === targetLower);
+  if (lowerSlug) return lowerSlug;
+
+  const chemxName = categories.find((c) => c.name.toLowerCase().includes('chemx'));
+  if (chemxName) return chemxName;
+
+  const chemxSlug = categories.find((c) => c.slug.toLowerCase().includes('chemx'));
+  if (chemxSlug) return chemxSlug;
+
+  const auditName = categories.find((c) => c.name.toLowerCase().includes('audit'));
+  if (auditName) return auditName;
+
+  const auditSlug = categories.find((c) => c.slug.toLowerCase().includes('audit'));
+  if (auditSlug) return auditSlug;
+
+  const generalName = categories.find((c) => c.name.toLowerCase().includes('general'));
+  if (generalName) return generalName;
+
+  return categories[0];
+};
+
+export const publishDiscussionViaHttp = async (token, repo, title, body, categoryName = DISCUSSION_CATEGORY) => {
+  if (!token) return { success: false, url: null, id: null, number: null, error: 'No GitHub token provided' };
+
+  const [owner, name] = repo.split('/');
+  if (!owner || !name) return { success: false, url: null, id: null, number: null, error: `Invalid repository format: ${repo}` };
+
+  try {
+    const metaQuery = `
+      query($owner: String!, $name: String!) {
+        repository(owner: $owner, name: $name) {
+          id
+          discussionCategories(first: 25) {
+            nodes {
+              id
+              name
+              slug
+              emoji
+            }
+          }
+        }
+      }
+    `;
+
+    const metaRes = await fetch('https://api.github.com/graphql', {
+      method: 'POST',
+      headers: {
+        'Authorization': `Bearer ${token}`,
+        'Content-Type': 'application/json',
+        'User-Agent': 'Chemical-X-Audit-CLI'
+      },
+      body: JSON.stringify({ query: metaQuery, variables: { owner, name } })
+    });
+
+    const metaJson = await metaRes.json();
+    if (metaJson.errors) {
+      return { success: false, url: null, id: null, number: null, error: metaJson.errors[0]?.message || 'GraphQL error fetching categories' };
+    }
+
+    const repositoryId = metaJson.data?.repository?.id;
+    const categories = metaJson.data?.repository?.discussionCategories?.nodes || [];
+
+    if (!repositoryId || categories.length === 0) {
+      return { success: false, url: null, id: null, number: null, error: `Repository ${repo} has no discussions enabled` };
+    }
+
+    const matchedCat = findMatchedCategory(categories, categoryName);
+
+    const mutation = `
+      mutation($repositoryId: ID!, $categoryId: ID!, $title: String!, $body: String!) {
+        createDiscussion(input: { repositoryId: $repositoryId, categoryId: $categoryId, title: $title, body: $body }) {
+          discussion {
+            id
+            number
+            url
+          }
+        }
+      }
+    `;
+
+    const postRes = await fetch('https://api.github.com/graphql', {
+      method: 'POST',
+      headers: {
+        'Authorization': `Bearer ${token}`,
+        'Content-Type': 'application/json',
+        'User-Agent': 'Chemical-X-Audit-CLI'
+      },
+      body: JSON.stringify({
+        query: mutation,
+        variables: { repositoryId, categoryId: matchedCat.id, title, body }
+      })
+    });
+
+    const postJson = await postRes.json();
+    if (postJson.errors) {
+      return { success: false, url: null, id: null, number: null, error: postJson.errors[0]?.message || 'Failed creating discussion' };
+    }
+
+    const disc = postJson.data?.createDiscussion?.discussion;
+    const url = disc?.url;
+    return {
+      success: Boolean(url),
+      url: url || null,
+      id: disc?.id || null,
+      number: disc?.number || null,
+      error: null
+    };
+  } catch (err) {
+    return { success: false, url: null, id: null, number: null, error: err.message };
+  }
+};
+
+export const viewDiscussionViaHttp = async (token, repo, discussionNumber) => {
+  const [owner, name] = repo.split('/');
+  if (!owner || !name) return null;
+
+  try {
+    const query = `
+      query($owner: String!, $name: String!, $number: Int!) {
+        repository(owner: $owner, name: $name) {
+          discussion(number: $number) {
+            id
+            number
+            title
+            body
+            url
+          }
+        }
+      }
+    `;
+    const res = await fetch('https://api.github.com/graphql', {
+      method: 'POST',
+      headers: {
+        'Authorization': `Bearer ${token}`,
+        'Content-Type': 'application/json',
+        'User-Agent': 'Chemical-X-Audit-CLI'
+      },
+      body: JSON.stringify({ query, variables: { owner, name, number: Number(discussionNumber) } })
+    });
+    const json = await res.json();
+    return json.data?.repository?.discussion || null;
+  } catch {
+    return null;
+  }
+};
+
+export const postDiscussionCommentViaHttp = async (token, discussionId, commentBody) => {
+  try {
+    const mutation = `
+      mutation($discussionId: ID!, $body: String!) {
+        addDiscussionComment(input: { discussionId: $discussionId, body: $body }) {
+          comment {
+            id
+            url
+          }
+        }
+      }
+    `;
+    const res = await fetch('https://api.github.com/graphql', {
+      method: 'POST',
+      headers: {
+        'Authorization': `Bearer ${token}`,
+        'Content-Type': 'application/json',
+        'User-Agent': 'Chemical-X-Audit-CLI'
+      },
+      body: JSON.stringify({ query: mutation, variables: { discussionId, body: commentBody } })
+    });
+    const json = await res.json();
+    return Boolean(json.data?.addDiscussionComment?.comment?.id);
+  } catch {
+    return false;
+  }
+};
+
+export const editDiscussionViaHttp = async (token, discussionId, title, body) => {
+  try {
+    const mutation = `
+      mutation($discussionId: ID!, $title: String!, $body: String!) {
+        updateDiscussion(input: { discussionId: $discussionId, title: $title, body: $body }) {
+          discussion {
+            id
+            number
+            url
+            title
+          }
+        }
+      }
+    `;
+    const res = await fetch('https://api.github.com/graphql', {
+      method: 'POST',
+      headers: {
+        'Authorization': `Bearer ${token}`,
+        'Content-Type': 'application/json',
+        'User-Agent': 'Chemical-X-Audit-CLI'
+      },
+      body: JSON.stringify({ query: mutation, variables: { discussionId, title, body } })
+    });
+    const json = await res.json();
+    return Boolean(json.data?.updateDiscussion?.discussion?.id);
+  } catch {
+    return false;
+  }
+};

package/cli/audit/social-publisher.js

@@ -0,0 +1,193 @@
+import {
+  DISCUSSION_CATEGORY,
+  DISCUSSION_CATEGORY_SLUG,
+  ORG_DISCUSSIONS_URL,
+  DEFAULT_DISCUSSION_REPO
+} from './social-constants.js';
+
+import {
+  getStoredDiscussion,
+  saveStoredDiscussion,
+  clearStoredDiscussion
+} from './discussion-store.js';
+
+import {
+  findMatchedCategory,
+  publishDiscussionViaHttp,
+  viewDiscussionViaHttp,
+  postDiscussionCommentViaHttp,
+  editDiscussionViaHttp
+} from './social-http.js';
+
+import {
+  publishDiscussionViaGh,
+  viewDiscussionViaGh,
+  postDiscussionCommentViaGh,
+  editDiscussionViaGh,
+  findExistingDiscussionViaGh
+} from './social-gh.js';
+
+export {
+  DISCUSSION_CATEGORY,
+  DISCUSSION_CATEGORY_SLUG,
+  ORG_DISCUSSIONS_URL,
+  DEFAULT_DISCUSSION_REPO
+} from './social-constants.js';
+
+export {
+  getStoredDiscussion,
+  saveStoredDiscussion,
+  clearStoredDiscussion
+} from './discussion-store.js';
+
+export {
+  findMatchedCategory,
+  publishDiscussionViaHttp,
+  viewDiscussionViaHttp,
+  postDiscussionCommentViaHttp,
+  editDiscussionViaHttp
+} from './social-http.js';
+
+export {
+  publishDiscussionViaGh,
+  viewDiscussionViaGh,
+  postDiscussionCommentViaGh,
+  editDiscussionViaGh,
+  findExistingDiscussionViaGh
+} from './social-gh.js';
+
+export const formatArchiveComment = (previousTitle, previousBody) => {
+  const archiveTimestamp = new Date().toUTCString();
+  return [
+    '## 📜 Previous Audit Snapshot (Archived)',
+    '',
+    `> **Archived on:** ${archiveTimestamp}`,
+    `> **Previous Status:** ${previousTitle || 'Prior Report'}`,
+    '',
+    '---',
+    '',
+    previousBody
+  ].join('\n');
+};
+
+export const publishDiscussion = async (repo, title, body, category = DISCUSSION_CATEGORY) => {
+  const envToken = process.env.GH_TOKEN || process.env.GITHUB_TOKEN;
+  if (envToken) {
+    const httpResult = await publishDiscussionViaHttp(envToken, repo, title, body, category);
+    if (httpResult.success) {
+      return httpResult;
+    }
+  }
+
+  return publishDiscussionViaGh(repo, title, body, category);
+};
+
+export const publishOrUpdateDiscussion = async (
+  repo = DEFAULT_DISCUSSION_REPO,
+  title,
+  body,
+  category = DISCUSSION_CATEGORY,
+  options = {}
+) => {
+  const envToken = process.env.GH_TOKEN || process.env.GITHUB_TOKEN;
+  const stored = getStoredDiscussion();
+  const targetRepo = repo || DEFAULT_DISCUSSION_REPO;
+
+  let existingDiscussion = null;
+
+  if (stored && stored.number && (!stored.repo || stored.repo === targetRepo)) {
+    if (envToken) {
+      existingDiscussion = await viewDiscussionViaHttp(envToken, targetRepo, stored.number);
+    }
+    if (!existingDiscussion) {
+      existingDiscussion = viewDiscussionViaGh(targetRepo, stored.number);
+    }
+  }
+
+  if (!existingDiscussion && options.projectName) {
+    existingDiscussion = findExistingDiscussionViaGh(targetRepo, options.projectName);
+  }
+
+  if (existingDiscussion && existingDiscussion.number) {
+    const discussionNumber = existingDiscussion.number;
+    const discussionId = existingDiscussion.id || stored?.discussionId;
+    const previousBody = existingDiscussion.body || '';
+
+    const hasPreviousBody = previousBody.trim().length > 0;
+    if (hasPreviousBody) {
+      const archiveComment = formatArchiveComment(existingDiscussion.title, previousBody);
+
+      if (envToken && discussionId) {
+        await postDiscussionCommentViaHttp(envToken, discussionId, archiveComment);
+      } else {
+        postDiscussionCommentViaGh(targetRepo, discussionNumber, archiveComment);
+      }
+    }
+
+    let editSuccess = false;
+    if (envToken && discussionId) {
+      editSuccess = await editDiscussionViaHttp(envToken, discussionId, title, body);
+    }
+    if (!editSuccess) {
+      editSuccess = editDiscussionViaGh(targetRepo, discussionNumber, title, body);
+    }
+
+    const fallbackUrl = `https://github.com/${targetRepo}/discussions/${discussionNumber}`;
+    const discussionUrl = existingDiscussion.url || stored?.url || fallbackUrl;
+
+    if (editSuccess) {
+      saveStoredDiscussion({
+        repo: targetRepo,
+        number: discussionNumber,
+        discussionId,
+        url: discussionUrl,
+        projectName: options.projectName || stored?.projectName || '',
+        website: options.website || stored?.website || '',
+        title,
+        lastPublishedAt: new Date().toISOString()
+      });
+
+      return {
+        success: true,
+        url: discussionUrl,
+        updated: true,
+        discussionNumber,
+        error: null
+      };
+    }
+  }
+
+  const pubResult = await publishDiscussion(targetRepo, title, body, category);
+  if (pubResult.success && pubResult.url) {
+    const match = pubResult.url.match(/\/discussions\/(\d+)/);
+    const parsedNumber = match ? parseInt(match[1], 10) : null;
+    const discussionNumber = pubResult.number || parsedNumber;
+
+    saveStoredDiscussion({
+      repo: targetRepo,
+      number: discussionNumber,
+      discussionId: pubResult.id || null,
+      url: pubResult.url,
+      projectName: options.projectName || '',
+      website: options.website || '',
+      title,
+      lastPublishedAt: new Date().toISOString()
+    });
+
+    return {
+      success: true,
+      url: pubResult.url,
+      updated: false,
+      discussionNumber,
+      error: null
+    };
+  }
+
+  return {
+    success: false,
+    url: null,
+    updated: false,
+    discussionNumber: null,
+    error: pubResult.error
+  };
+};

package/cli/audit/social.d.ts

@@ -0,0 +1,69 @@
+import type { AuditReport } from './types';
+import type { AuditSnapshot } from './history';
+
+export interface DiscussionContent {
+  readonly title: string;
+  readonly category: string;
+  readonly categorySlug: string;
+  readonly body: string;
+}
+
+export interface GitRepoInfo {
+  readonly owner: string;
+  readonly repo: string;
+  readonly nameWithOwner: string;
+  readonly url: string;
+}
+
+export declare const DISCUSSION_CATEGORY: string;
+export declare const DISCUSSION_CATEGORY_SLUG: string;
+export declare const ORG_DISCUSSIONS_URL: string;
+export declare const DEFAULT_DISCUSSION_REPO: string;
+
+export declare function parseGitRemoteUrl(url: string): GitRepoInfo | null;
+export declare function detectGitRepoInfo(cwd?: string): GitRepoInfo;
+export declare function detectGitHubUser(preferredUser?: string): string;
+export declare function copyToClipboard(text: string): boolean;
+export declare function resolveBadgeColor(score: number): string;
+export declare function resolveHotspotTierText(lineCount: number): string;
+export declare function resolvePillarProgressionBadge(isImproved: boolean, beforeStatus: string, afterStatus: string): string;
+export declare function formatWebUrl(url: string): string;
+export declare function resolveExcessCostPerPass(tokensObj?: any, fallbackCostPerMillion?: number): number;
+export declare function resolveMonthlyWastePerDev(tokensObj?: any, fallbackCostPerMillion?: number): number;
+export declare function resolveWeeklyWastePerDev(tokensObj?: any, fallbackCostPerMillion?: number): number;
+export declare function generateDiscussionContent(report: AuditReport, username: string, projectName?: string, repoUrl?: string, liveUrl?: string): DiscussionContent;
+export declare function generateTransformationDiscussionContent(beforeSnapshot: AuditSnapshot, afterSnapshot: AuditSnapshot, username: string, projectName?: string, repoUrl?: string, liveUrl?: string): DiscussionContent;
+export declare function publishDiscussionViaGh(repo: string, title: string, body: string, category?: string): { success: boolean; url: string | null; error?: string | null };
+export declare function publishDiscussionViaHttp(token: string, repo: string, title: string, body: string, categoryName?: string): Promise<{ success: boolean; url: string | null; error?: string | null }>;
+export declare function publishDiscussion(repo: string, title: string, body: string, category?: string): Promise<{ success: boolean; url: string | null; error?: string | null }>;
+
+export interface StoredDiscussion {
+  readonly repo: string;
+  readonly number: number | null;
+  readonly discussionId?: string | null;
+  readonly url: string;
+  readonly projectName?: string;
+  readonly website?: string;
+  readonly title: string;
+  readonly lastPublishedAt: string;
+}
+
+export interface DiscussionPublishResult {
+  readonly success: boolean;
+  readonly url: string | null;
+  readonly updated?: boolean;
+  readonly discussionNumber?: number | null;
+  readonly error?: string | null;
+}
+
+export declare function getStoredDiscussion(cwd?: string): StoredDiscussion | null;
+export declare function saveStoredDiscussion(data: StoredDiscussion, cwd?: string): boolean;
+export declare function clearStoredDiscussion(cwd?: string): boolean;
+export declare function formatArchiveComment(previousTitle: string, previousBody: string): string;
+export declare function publishOrUpdateDiscussion(
+  repo?: string,
+  title?: string,
+  body?: string,
+  category?: string,
+  options?: { readonly projectName?: string; readonly website?: string }
+): Promise<DiscussionPublishResult>;