hale-commenting-system 2.0.2 → 2.0.4

package/dist/services/githubAdapter.d.ts

@@ -0,0 +1,56 @@
+export interface GitHubUser {
+    login: string;
+    avatar: string;
+}
+export declare const GITHUB_TOKEN_STORAGE_KEY = "github_access_token";
+export declare const GITHUB_USER_STORAGE_KEY = "github_user";
+export declare const storeGitHubAuth: (token: string, user: GitHubUser) => void;
+export declare const clearGitHubAuth: () => void;
+export declare const getStoredToken: () => string | null;
+export declare const getStoredUser: () => GitHubUser | null;
+export declare const isGitHubConfigured: () => boolean;
+export declare const diagnoseGitHubSetup: () => {
+    hasToken: boolean;
+    hasUser: boolean;
+    hasOwner: boolean;
+    hasRepo: boolean;
+    isComplete: boolean;
+};
+export interface GitHubResult<T = any> {
+    success: boolean;
+    data?: T;
+    error?: string;
+}
+export declare const githubAdapter: {
+    createIssue(params: {
+        title: string;
+        body: string;
+        route: string;
+        xPercent: number;
+        yPercent: number;
+        version?: string;
+    }): Promise<GitHubResult<{
+        number: number;
+        html_url: string;
+    }>>;
+    createComment(issueNumber: number, body: string): Promise<GitHubResult>;
+    fetchIssuesForRoute(route: string): Promise<GitHubResult<any[]>>;
+    fetchIssuesForRouteAndVersion(route: string, version?: string): Promise<GitHubResult<any[]>>;
+    fetchIssueComments(issueNumber: number): Promise<GitHubResult<any[]>>;
+    updateComment(commentId: number, body: string): Promise<GitHubResult>;
+    deleteComment(commentId: number): Promise<GitHubResult>;
+    closeIssue(issueNumber: number): Promise<GitHubResult>;
+    reopenIssue(issueNumber: number): Promise<GitHubResult>;
+    getRepoFile(path: string): Promise<GitHubResult<{
+        text: string;
+        sha: string;
+    } | null>>;
+    putRepoFile(params: {
+        path: string;
+        text: string;
+        message: string;
+        sha?: string;
+    }): Promise<GitHubResult<{
+        sha: string;
+    }>>;
+};

package/dist/services/githubAdapter.js

@@ -0,0 +1,321 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.githubAdapter = exports.diagnoseGitHubSetup = exports.isGitHubConfigured = exports.getStoredUser = exports.getStoredToken = exports.clearGitHubAuth = exports.storeGitHubAuth = exports.GITHUB_USER_STORAGE_KEY = exports.GITHUB_TOKEN_STORAGE_KEY = void 0;
+exports.GITHUB_TOKEN_STORAGE_KEY = 'github_access_token';
+exports.GITHUB_USER_STORAGE_KEY = 'github_user';
+const storeGitHubAuth = (token, user) => {
+    localStorage.setItem(exports.GITHUB_TOKEN_STORAGE_KEY, token);
+    localStorage.setItem(exports.GITHUB_USER_STORAGE_KEY, JSON.stringify(user));
+};
+exports.storeGitHubAuth = storeGitHubAuth;
+const clearGitHubAuth = () => {
+    localStorage.removeItem(exports.GITHUB_TOKEN_STORAGE_KEY);
+    localStorage.removeItem(exports.GITHUB_USER_STORAGE_KEY);
+};
+exports.clearGitHubAuth = clearGitHubAuth;
+const getStoredToken = () => {
+    return localStorage.getItem(exports.GITHUB_TOKEN_STORAGE_KEY);
+};
+exports.getStoredToken = getStoredToken;
+const getStoredUser = () => {
+    const raw = localStorage.getItem(exports.GITHUB_USER_STORAGE_KEY);
+    if (!raw)
+        return null;
+    try {
+        return JSON.parse(raw);
+    }
+    catch {
+        return null;
+    }
+};
+exports.getStoredUser = getStoredUser;
+const isGitHubConfigured = () => {
+    return Boolean((0, exports.getStoredToken)() && process.env.VITE_GITHUB_OWNER && process.env.VITE_GITHUB_REPO);
+};
+exports.isGitHubConfigured = isGitHubConfigured;
+const diagnoseGitHubSetup = () => {
+    const token = (0, exports.getStoredToken)();
+    const user = (0, exports.getStoredUser)();
+    const owner = process.env.VITE_GITHUB_OWNER;
+    const repo = process.env.VITE_GITHUB_REPO;
+    console.log('🔍 GitHub Configuration Diagnostic:');
+    console.log('  Token:', token ? `Present (${token.substring(0, 10)}...)` : 'Missing ❌');
+    console.log('  User:', user ? `${user.login}` : 'Not logged in ❌');
+    console.log('  Owner:', owner || 'Missing ❌');
+    console.log('  Repo:', repo || 'Missing ❌');
+    console.log('  Full repo path:', owner && repo ? `${owner}/${repo}` : 'Incomplete ❌');
+    console.log('\n💡 To fix 403 Forbidden error:');
+    console.log('  1. Make sure you have write access to the repository');
+    console.log('  2. Check that issues are enabled on the repository');
+    console.log('  3. Re-authenticate to get a fresh token with correct scopes');
+    console.log('  4. Token needs "repo" scope for private repos or "public_repo" for public repos');
+    return {
+        hasToken: !!token,
+        hasUser: !!user,
+        hasOwner: !!owner,
+        hasRepo: !!repo,
+        isComplete: !!(token && user && owner && repo)
+    };
+};
+exports.diagnoseGitHubSetup = diagnoseGitHubSetup;
+async function githubProxyRequest(method, endpoint, data) {
+    const token = (0, exports.getStoredToken)();
+    if (!token) {
+        throw new Error('Not authenticated with GitHub');
+    }
+    console.log(`🔵 GitHub API Request:`, { method, endpoint, hasData: !!data });
+    const resp = await fetch('/api/github-api', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ token, method, endpoint, data }),
+    });
+    const payload = await resp.json();
+    console.log(`🔵 GitHub API Response:`, {
+        status: resp.status,
+        ok: resp.ok,
+        payload
+    });
+    if (!resp.ok) {
+        const message = (payload && (payload.message || payload.error)) || `GitHub API error (${resp.status})`;
+        if (resp.status === 403) {
+            console.error(`❌ 403 Forbidden - Possible causes:
+        1. Token doesn't have 'repo' or 'public_repo' scope
+        2. You don't have write access to the repository
+        3. Issues are disabled on the repository
+        4. Token has expired or been revoked
+
+        Current config:
+        - Owner: ${process.env.VITE_GITHUB_OWNER}
+        - Repo: ${process.env.VITE_GITHUB_REPO}
+        - Endpoint: ${endpoint}
+      `);
+        }
+        throw new Error(message);
+    }
+    return payload;
+}
+const encodePath = (path) => {
+    return path
+        .split('/')
+        .map((seg) => encodeURIComponent(seg))
+        .join('/');
+};
+const base64EncodeUtf8 = (input) => {
+    // btoa expects latin1; convert safely for utf-8
+    return btoa(unescape(encodeURIComponent(input)));
+};
+const base64DecodeUtf8 = (input) => {
+    return decodeURIComponent(escape(atob(input)));
+};
+const getLabelNames = (issue) => {
+    const labels = issue?.labels;
+    if (!Array.isArray(labels))
+        return [];
+    return labels
+        .map((l) => (typeof l === 'string' ? l : l?.name))
+        .filter((n) => typeof n === 'string');
+};
+const issueHasAnyVersion = (issue) => {
+    const labelNames = getLabelNames(issue);
+    if (labelNames.some((n) => n.startsWith('version:')))
+        return true;
+    const body = issue?.body || '';
+    return body.includes('Version:');
+};
+exports.githubAdapter = {
+    async createIssue(params) {
+        if (!(0, exports.isGitHubConfigured)())
+            return { success: false, error: 'Please sign in with GitHub' };
+        const owner = process.env.VITE_GITHUB_OWNER;
+        const repo = process.env.VITE_GITHUB_REPO;
+        try {
+            const metadata = [
+                `- Route: \`${params.route}\``,
+                params.version ? `- Version: \`${params.version}\`` : null,
+                `- Coordinates: \`(${params.xPercent.toFixed(1)}%, ${params.yPercent.toFixed(1)}%)\``,
+            ]
+                .filter(Boolean)
+                .join('\n');
+            const issueBody = {
+                title: params.title,
+                body: `${params.body}\n\n---\n**Metadata:**\n${metadata}`,
+            };
+            const data = await githubProxyRequest('POST', `/repos/${owner}/${repo}/issues`, issueBody);
+            // Add helpful labels (non-fatal if it fails)
+            try {
+                const labels = [
+                    'hale-comment',
+                    `route:${params.route}`,
+                    `coords:${Math.round(params.xPercent)},${Math.round(params.yPercent)}`,
+                ];
+                if (params.version)
+                    labels.push(`version:${params.version}`);
+                await githubProxyRequest('POST', `/repos/${owner}/${repo}/issues/${data.number}/labels`, { labels });
+            }
+            catch {
+                // ignore label failures
+            }
+            return { success: true, data };
+        }
+        catch (e) {
+            return { success: false, error: e?.message || 'Failed to create issue' };
+        }
+    },
+    async createComment(issueNumber, body) {
+        if (!(0, exports.isGitHubConfigured)())
+            return { success: false, error: 'Please sign in with GitHub' };
+        const owner = process.env.VITE_GITHUB_OWNER;
+        const repo = process.env.VITE_GITHUB_REPO;
+        try {
+            const data = await githubProxyRequest('POST', `/repos/${owner}/${repo}/issues/${issueNumber}/comments`, { body });
+            return { success: true, data };
+        }
+        catch (e) {
+            return { success: false, error: e?.message || 'Failed to create comment' };
+        }
+    },
+    async fetchIssuesForRoute(route) {
+        return exports.githubAdapter.fetchIssuesForRouteAndVersion(route);
+    },
+    async fetchIssuesForRouteAndVersion(route, version) {
+        if (!(0, exports.isGitHubConfigured)())
+            return { success: false, error: 'Please sign in with GitHub' };
+        const owner = process.env.VITE_GITHUB_OWNER;
+        const repo = process.env.VITE_GITHUB_REPO;
+        try {
+            const data = await githubProxyRequest('GET', `/repos/${owner}/${repo}/issues?state=all&per_page=100`);
+            // Filter by metadata OR labels (route:${route}), and optionally by version
+            const filtered = (Array.isArray(data) ? data : [])
+                .filter((issue) => {
+                const body = issue?.body || '';
+                const labels = getLabelNames(issue);
+                const bodyMatch = body.includes(`Route: \`${route}\``);
+                const labelMatch = labels.includes(`route:${route}`);
+                return bodyMatch || labelMatch;
+            })
+                .filter((issue) => {
+                if (!version)
+                    return true;
+                const labels = getLabelNames(issue);
+                const body = issue?.body || '';
+                const versionLabelMatch = labels.includes(`version:${version}`);
+                const bodyVersionMatch = body.includes(`Version: \`${version}\``);
+                // Back-compat: if an issue has no version metadata at all, treat it as default "1"
+                if (!issueHasAnyVersion(issue) && version === '1')
+                    return true;
+                return versionLabelMatch || bodyVersionMatch;
+            });
+            return { success: true, data: filtered };
+        }
+        catch (e) {
+            return { success: false, error: e?.message || 'Failed to fetch issues' };
+        }
+    },
+    async fetchIssueComments(issueNumber) {
+        if (!(0, exports.isGitHubConfigured)())
+            return { success: false, error: 'Please sign in with GitHub' };
+        const owner = process.env.VITE_GITHUB_OWNER;
+        const repo = process.env.VITE_GITHUB_REPO;
+        try {
+            const data = await githubProxyRequest('GET', `/repos/${owner}/${repo}/issues/${issueNumber}/comments?per_page=100`);
+            return { success: true, data };
+        }
+        catch (e) {
+            return { success: false, error: e?.message || 'Failed to fetch issue comments' };
+        }
+    },
+    async updateComment(commentId, body) {
+        if (!(0, exports.isGitHubConfigured)())
+            return { success: false, error: 'Please sign in with GitHub' };
+        const owner = process.env.VITE_GITHUB_OWNER;
+        const repo = process.env.VITE_GITHUB_REPO;
+        try {
+            const data = await githubProxyRequest('PATCH', `/repos/${owner}/${repo}/issues/comments/${commentId}`, { body });
+            return { success: true, data };
+        }
+        catch (e) {
+            return { success: false, error: e?.message || 'Failed to update comment' };
+        }
+    },
+    async deleteComment(commentId) {
+        if (!(0, exports.isGitHubConfigured)())
+            return { success: false, error: 'Please sign in with GitHub' };
+        const owner = process.env.VITE_GITHUB_OWNER;
+        const repo = process.env.VITE_GITHUB_REPO;
+        try {
+            await githubProxyRequest('DELETE', `/repos/${owner}/${repo}/issues/comments/${commentId}`);
+            return { success: true, data: {} };
+        }
+        catch (e) {
+            return { success: false, error: e?.message || 'Failed to delete comment' };
+        }
+    },
+    async closeIssue(issueNumber) {
+        if (!(0, exports.isGitHubConfigured)())
+            return { success: false, error: 'Please sign in with GitHub' };
+        const owner = process.env.VITE_GITHUB_OWNER;
+        const repo = process.env.VITE_GITHUB_REPO;
+        try {
+            const data = await githubProxyRequest('PATCH', `/repos/${owner}/${repo}/issues/${issueNumber}`, { state: 'closed' });
+            return { success: true, data };
+        }
+        catch (e) {
+            return { success: false, error: e?.message || 'Failed to close issue' };
+        }
+    },
+    async reopenIssue(issueNumber) {
+        if (!(0, exports.isGitHubConfigured)())
+            return { success: false, error: 'Please sign in with GitHub' };
+        const owner = process.env.VITE_GITHUB_OWNER;
+        const repo = process.env.VITE_GITHUB_REPO;
+        try {
+            const data = await githubProxyRequest('PATCH', `/repos/${owner}/${repo}/issues/${issueNumber}`, { state: 'open' });
+            return { success: true, data };
+        }
+        catch (e) {
+            return { success: false, error: e?.message || 'Failed to reopen issue' };
+        }
+    },
+    async getRepoFile(path) {
+        if (!(0, exports.isGitHubConfigured)())
+            return { success: false, error: 'Please sign in with GitHub' };
+        const owner = process.env.VITE_GITHUB_OWNER;
+        const repo = process.env.VITE_GITHUB_REPO;
+        try {
+            const data = await githubProxyRequest('GET', `/repos/${owner}/${repo}/contents/${encodePath(path)}`);
+            const content = typeof data?.content === 'string' ? data.content.replace(/\n/g, '') : '';
+            const sha = data?.sha;
+            if (!content || !sha)
+                return { success: true, data: null };
+            const text = base64DecodeUtf8(content);
+            return { success: true, data: { text, sha } };
+        }
+        catch (e) {
+            // If file doesn't exist yet, treat as empty
+            if (String(e?.message || '').toLowerCase().includes('not found')) {
+                return { success: true, data: null };
+            }
+            return { success: false, error: e?.message || 'Failed to read repo file' };
+        }
+    },
+    async putRepoFile(params) {
+        if (!(0, exports.isGitHubConfigured)())
+            return { success: false, error: 'Please sign in with GitHub' };
+        const owner = process.env.VITE_GITHUB_OWNER;
+        const repo = process.env.VITE_GITHUB_REPO;
+        try {
+            const payload = {
+                message: params.message,
+                content: base64EncodeUtf8(params.text),
+            };
+            if (params.sha)
+                payload.sha = params.sha;
+            const data = await githubProxyRequest('PUT', `/repos/${owner}/${repo}/contents/${encodePath(params.path)}`, payload);
+            const newSha = data?.content?.sha;
+            return { success: true, data: { sha: newSha || params.sha || '' } };
+        }
+        catch (e) {
+            return { success: false, error: e?.message || 'Failed to write repo file' };
+        }
+    },
+};

package/dist/types/index.d.ts

@@ -0,0 +1,25 @@
+export interface Comment {
+    id: string;
+    author?: string;
+    text: string;
+    createdAt: string;
+    githubCommentId?: number;
+    parentCommentId?: string;
+    parentGitHubCommentId?: number;
+}
+export type SyncStatus = 'synced' | 'local' | 'pending' | 'syncing' | 'error';
+export type ThreadStatus = 'open' | 'closed';
+export interface Thread {
+    id: string;
+    xPercent: number;
+    yPercent: number;
+    route: string;
+    version?: string;
+    comments: Comment[];
+    issueNumber?: number;
+    issueUrl?: string;
+    provider?: 'github';
+    syncStatus?: SyncStatus;
+    syncError?: string;
+    status?: ThreadStatus;
+}

package/dist/types/index.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/utils/version.d.ts

@@ -0,0 +1 @@
+export declare const getVersionFromPathOrQuery: (pathname: string, search: string) => string | undefined;

package/dist/utils/version.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getVersionFromPathOrQuery = void 0;
+const getVersionFromPathOrQuery = (pathname, search) => {
+    try {
+        const params = new URLSearchParams(search || '');
+        const fromQuery = params.get('version') || params.get('v');
+        if (fromQuery && String(fromQuery).trim())
+            return String(fromQuery).trim();
+        // Common pattern: /v3/... or /version/3/...
+        const m1 = pathname.match(/^\/v(\d+)(?:\/|$)/i);
+        if (m1?.[1])
+            return m1[1];
+        const m2 = pathname.match(/\/version\/(\d+)(?:\/|$)/i);
+        if (m2?.[1])
+            return m2[1];
+    }
+    catch {
+        // ignore
+    }
+    return undefined;
+};
+exports.getVersionFromPathOrQuery = getVersionFromPathOrQuery;

package/package.json

@@ -1,31 +1,39 @@
 {
   "name": "hale-commenting-system",
-  "version": "2.0.2",
-  "description": "Local-first commenting system for React applications with localStorage persistence",
-  "main": "./dist/index.js",
-  "module": "./dist/index.mjs",
-  "types": "./dist/index.d.ts",
+  "version": "2.0.4",
+  "description": "Commenting system for PatternFly Seed projects with GitHub and Jira integration",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
   "bin": {
-    "hale-commenting-system": "./cli/dist/index.js"
-  },
-  "exports": {
-    ".": {
-      "import": "./dist/index.mjs",
-      "require": "./dist/index.js",
-      "types": "./dist/index.d.ts"
-    }
+    "hale-commenting": "./bin/hale-commenting.js"
   },
   "files": [
     "dist",
-    "cli/dist"
+    "bin",
+    "templates",
+    "README.md"
   ],
   "scripts": {
-    "build": "npm run build:lib && npm run build:cli",
-    "build:lib": "tsup",
-    "build:cli": "cd cli && npm run build",
-    "dev": "tsup --watch",
+    "build": "tsc && npm run build:cli && npm run build:postinstall",
+    "build:cli": "tsc --project tsconfig.cli.json",
+    "build:postinstall": "tsc --project tsconfig.postinstall.json",
     "type-check": "tsc --noEmit",
-    "prepare": "npm run build"
+    "prepublishOnly": "npm run build"
+  },
+  "postinstall": "node bin/postinstall.js",
+  "keywords": [
+    "commenting",
+    "feedback",
+    "patternfly",
+    "github",
+    "jira",
+    "uxd"
+  ],
+  "author": "Justin X. Hale",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/JustinXHale/pfseed-commenting-system.git"
   },
   "peerDependencies": {
     "@patternfly/react-core": "^6.0.0",
@@ -35,26 +43,19 @@
     "react-router-dom": "^6.0.0 || ^7.0.0"
   },
   "dependencies": {
-    "commander": "^12.0.0",
-    "inquirer": "^9.2.15",
-    "chalk": "^5.3.0",
-    "ora": "^8.0.1"
+    "chalk": "^4.1.2",
+    "inquirer": "^9.3.8",
+    "node-fetch": "^2.7.0"
   },
   "devDependencies": {
-    "@types/react": "^18.0.0",
-    "@types/react-dom": "^18.0.0",
-    "tsup": "^8.0.2",
-    "typescript": "^5.4.5"
+    "@types/inquirer": "^9.0.9",
+    "@types/node": "^20.19.27",
+    "@types/node-fetch": "^2.6.13",
+    "@types/react": "^18.2.45",
+    "@types/react-dom": "^18.2.18",
+    "typescript": "^5.9.3"
   },
-  "keywords": [
-    "react",
-    "comments",
-    "feedback",
-    "localstorage",
-    "patternfly",
-    "cli",
-    "local-first"
-  ],
-  "author": "Justin Hale",
-  "license": "MIT"
+  "engines": {
+    "node": ">=16.0.0"
+  }
 }