fraim-framework 2.0.52 → 2.0.55

package/registry/scripts/productivity/build-productivity-csv.mjs

@@ -0,0 +1,242 @@
+#!/usr/bin/env node
+/**
+ * Build productivity-report.csv from pre-fetched data.
+ * Repository-agnostic version - works with any repository's data files.
+ * 
+ * Run: node build-productivity-csv.mjs after productivity-report.sh (or manual gh fetches).
+ */
+
+import fs from 'fs';
+import path from 'path';
+
+const workDir = process.cwd();
+const dataDir = path.join(workDir, '.productivity-data');
+const commitsPath = path.join(dataDir, 'commits.txt');
+const prsDetailsPath = path.join(dataDir, 'prs_details.txt');
+const prsPath = path.join(dataDir, 'prs.txt'); // fallback from list API
+const issuesPath = path.join(dataDir, 'issues_closed.txt');
+
+// Create output directory and timestamped filename
+const outputDir = path.join(workDir, 'docs', 'productivity-report');
+const timestamp = new Date().toISOString().slice(0, 16).replace(/[:-]/g, '').replace('T', '-');
+const outPath = path.join(outputDir, `productivity-report-${timestamp}.csv`);
+
+// Ensure output directory exists
+if (!fs.existsSync(outputDir)) {
+    fs.mkdirSync(outputDir, { recursive: true });
+    console.error(`✅ Created output directory: ${outputDir}`);
+}
+
+// Utility functions for date processing
+function getDateKey(iso) {
+    return iso.slice(0, 10);
+}
+
+function getWeekKey(iso) {
+    const d = new Date(iso);
+    const start = new Date(d);
+    start.setDate(d.getDate() - d.getDay()); // Sunday as week start
+    return start.toISOString().slice(0, 10);
+}
+
+function getMonthKey(iso) {
+    return iso.slice(0, 7);
+}
+
+// Data aggregation objects
+const byDay = {};
+const byWeek = {};
+const byMonth = {};
+
+function ensurePeriod(day, week, month) {
+    byDay[day] = byDay[day] || { commits: 0, prs: 0, issuesResolved: 0, comments: 0 };
+    byWeek[week] = byWeek[week] || { commits: 0, prs: 0, issuesResolved: 0, comments: 0 };
+    byMonth[month] = byMonth[month] || { commits: 0, prs: 0, issuesResolved: 0, comments: 0 };
+}
+
+// Check if data directory exists
+if (!fs.existsSync(dataDir)) {
+    console.error(`Error: Data directory not found: ${dataDir}`);
+    console.error('Run productivity-report.sh first to fetch data.');
+    process.exit(1);
+}
+
+console.error(`Processing data from: ${dataDir}`);
+
+// Process commits
+if (fs.existsSync(commitsPath)) {
+    try {
+        const content = fs.readFileSync(commitsPath, 'utf8').trim();
+        const lines = content ? content.split('\n').filter(Boolean) : [];
+        
+        for (const line of lines) {
+            const trimmedLine = line.trim();
+            if (!trimmedLine) continue;
+            
+            try {
+                const d = getDateKey(trimmedLine);
+                const w = getWeekKey(trimmedLine);
+                const m = getMonthKey(trimmedLine);
+                ensurePeriod(d, w, m);
+                byDay[d].commits++;
+                byWeek[w].commits++;
+                byMonth[m].commits++;
+            } catch (dateError) {
+                console.error(`Warning: Invalid date format in commits: ${trimmedLine}`);
+            }
+        }
+        console.error(`✅ Processed ${lines.length} commits`);
+    } catch (error) {
+        console.error(`Warning: Could not process commits file:`, error.message);
+    }
+} else {
+    console.error(`Warning: Commits file not found: ${commitsPath}`);
+}
+
+// Process PRs: "created_at,comments,review_comments" (prs_details.txt has full counts)
+const prsSource = fs.existsSync(prsDetailsPath) ? prsDetailsPath : prsPath;
+if (fs.existsSync(prsSource)) {
+    try {
+        const content = fs.readFileSync(prsSource, 'utf8').trim();
+        const lines = content ? content.split('\n').filter(Boolean) : [];
+        
+        let validPRs = 0;
+        let totalCommentCount = 0;
+        
+        for (const line of lines) {
+            const trimmedLine = line.trim();
+            if (!trimmedLine) continue;
+            
+            const parts = trimmedLine.split(',');
+            if (parts.length < 1) {
+                console.error(`Warning: Invalid PR line format: ${trimmedLine}`);
+                continue;
+            }
+            
+            const createdAt = parts[0];
+            const comments = parseInt(parts[1] || '0', 10) || 0;
+            const reviewComments = parseInt(parts[2] || '0', 10) || 0;
+            const totalComments = comments + reviewComments;
+            
+            try {
+                const d = getDateKey(createdAt);
+                const w = getWeekKey(createdAt);
+                const m = getMonthKey(createdAt);
+                ensurePeriod(d, w, m);
+                byDay[d].prs++;
+                byDay[d].comments += totalComments;
+                byWeek[w].prs++;
+                byWeek[w].comments += totalComments;
+                byMonth[m].prs++;
+                byMonth[m].comments += totalComments;
+                
+                validPRs++;
+                totalCommentCount += totalComments;
+            } catch (dateError) {
+                console.error(`Warning: Invalid date format in PRs: ${createdAt}`);
+            }
+        }
+        
+        const sourceType = prsSource.includes('details') ? 'detailed' : 'list API';
+        console.error(`✅ Processed ${validPRs} PRs (${sourceType}) - Total comments: ${totalCommentCount}`);
+    } catch (error) {
+        console.error(`Warning: Could not process PRs file:`, error.message);
+    }
+} else {
+    console.error(`Warning: PRs file not found: ${prsSource}`);
+}
+
+// Process closed issues (non-PR): "closed_at"
+if (fs.existsSync(issuesPath)) {
+    try {
+        const content = fs.readFileSync(issuesPath, 'utf8').trim();
+        const lines = content ? content.split('\n').filter(Boolean) : [];
+        
+        let validIssues = 0;
+        
+        for (const line of lines) {
+            const closedAt = line.trim();
+            if (!closedAt) continue;
+            
+            try {
+                const d = getDateKey(closedAt);
+                const w = getWeekKey(closedAt);
+                const m = getMonthKey(closedAt);
+                ensurePeriod(d, w, m);
+                byDay[d].issuesResolved++;
+                byWeek[w].issuesResolved++;
+                byMonth[m].issuesResolved++;
+                validIssues++;
+            } catch (dateError) {
+                console.error(`Warning: Invalid date format in issues: ${closedAt}`);
+            }
+        }
+        console.error(`✅ Processed ${validIssues} closed issues`);
+    } catch (error) {
+        console.error(`Warning: Could not process issues file:`, error.message);
+    }
+} else {
+    console.error(`Warning: Issues file not found: ${issuesPath}`);
+}
+
+// Build CSV content
+const lines = ['period_type,period,commits,prs_created,issues_resolved,comments_total'];
+const sortKeys = (obj) => Object.keys(obj).sort();
+
+// Add daily data
+const dailyKeys = sortKeys(byDay);
+for (const key of dailyKeys) {
+    const data = byDay[key];
+    lines.push(`day,${key},${data.commits},${data.prs},${data.issuesResolved},${data.comments}`);
+}
+
+// Add separator and weekly data
+lines.push('');
+const weeklyKeys = sortKeys(byWeek);
+for (const key of weeklyKeys) {
+    const data = byWeek[key];
+    lines.push(`week,${key},${data.commits},${data.prs},${data.issuesResolved},${data.comments}`);
+}
+
+// Add separator and monthly data
+lines.push('');
+const monthlyKeys = sortKeys(byMonth);
+for (const key of monthlyKeys) {
+    const data = byMonth[key];
+    lines.push(`month,${key},${data.commits},${data.prs},${data.issuesResolved},${data.comments}`);
+}
+
+const content = lines.join('\n');
+
+// Write CSV file with fallback for locked files
+try {
+    fs.writeFileSync(outPath, content, 'utf8');
+    console.error(`✅ Successfully wrote: ${outPath}`);
+    
+    // Report summary statistics
+    const totalDays = dailyKeys.length;
+    const totalWeeks = weeklyKeys.length;
+    const totalMonths = monthlyKeys.length;
+    const csvLines = lines.length;
+    
+    console.error(`📊 Report Summary:`);
+    console.error(`   Daily periods: ${totalDays}`);
+    console.error(`   Weekly periods: ${totalWeeks}`);
+    console.error(`   Monthly periods: ${totalMonths}`);
+    console.error(`   CSV lines: ${csvLines}`);
+    
+} catch (error) {
+    if (error.code === 'EBUSY' || error.code === 'EPERM') {
+        const altPath = path.join(outputDir, 'productivity-report-new.csv');
+        try {
+            fs.writeFileSync(altPath, content, 'utf8');
+            console.error(`⚠️  Original file locked - wrote to: ${altPath}`);
+        } catch (altError) {
+            console.error(`❌ Error: Could not write to either file:`, altError.message);
+            process.exit(1);
+        }
+    } else {
+        console.error(`❌ Error writing CSV file:`, error.message);
+        process.exit(1);
+    }
+}

package/registry/scripts/productivity/fetch-pr-details.mjs

@@ -0,0 +1,144 @@
+#!/usr/bin/env node
+/**
+ * Fetch comments + review_comments for each PR (list API returns null).
+ * Reads .productivity-data/prs_list_raw.json, outputs prs_details.txt
+ * 
+ * Repository-agnostic version - uses REPO_FULL environment variable or auto-detects
+ */
+
+import { execSync } from 'child_process';
+import fs from 'fs';
+import path from 'path';
+
+// Function to detect repository from git remote
+function detectRepository() {
+    try {
+        const remoteUrl = execSync('git remote get-url origin', { encoding: 'utf8' }).trim();
+        const match = remoteUrl.match(/github\.com[:/]([^/]+\/[^/]+?)(?:\.git)?$/);
+        return match ? match[1] : null;
+    } catch (error) {
+        return null;
+    }
+}
+
+// Determine repository
+let REPO = process.env.REPO_FULL;
+
+if (!REPO && process.env.REPO_OWNER && process.env.REPO_NAME) {
+    REPO = `${process.env.REPO_OWNER}/${process.env.REPO_NAME}`;
+}
+
+if (!REPO) {
+    REPO = detectRepository();
+}
+
+if (!REPO) {
+    console.error('Error: Could not determine repository.');
+    console.error('Set REPO_FULL environment variable or run from a git repository with GitHub remote.');
+    console.error('Example: export REPO_FULL="owner/repo"');
+    process.exit(1);
+}
+
+// Validate repository format
+if (!/^[a-zA-Z0-9._-]+\/[a-zA-Z0-9._-]+$/.test(REPO)) {
+    console.error(`Error: Invalid repository format: ${REPO}`);
+    console.error('Expected format: owner/repository-name');
+    process.exit(1);
+}
+
+console.error(`Fetching PR details for repository: ${REPO}`);
+
+const DATA_DIR = path.join(process.cwd(), '.productivity-data');
+const prsListPath = path.join(DATA_DIR, 'prs_list_raw.json');
+
+// Check if input file exists
+if (!fs.existsSync(prsListPath)) {
+    console.error(`Error: ${prsListPath} not found`);
+    console.error('Run the main productivity-report.sh script first, or fetch PRs list manually.');
+    process.exit(1);
+}
+
+// Read and parse PRs list
+let prs;
+try {
+    const raw = fs.readFileSync(prsListPath, 'utf8');
+    prs = raw.trim().split('\n').filter(Boolean).map((line) => {
+        try {
+            return JSON.parse(line);
+        } catch (parseError) {
+            console.error(`Warning: Could not parse line: ${line}`);
+            return null;
+        }
+    }).filter(Boolean);
+} catch (error) {
+    console.error(`Error reading ${prsListPath}:`, error.message);
+    process.exit(1);
+}
+
+if (prs.length === 0) {
+    console.error('No PRs found in the list. Creating empty prs_details.txt');
+    fs.writeFileSync(path.join(DATA_DIR, 'prs_details.txt'), '');
+    process.exit(0);
+}
+
+console.error(`Processing ${prs.length} PRs...`);
+
+const outPath = path.join(DATA_DIR, 'prs_details.txt');
+const out = [];
+let successCount = 0;
+let errorCount = 0;
+
+for (let i = 0; i < prs.length; i++) {
+    const pr = prs[i];
+    
+    if (!pr.number || !pr.created_at) {
+        console.error(`Warning: Invalid PR data at index ${i}:`, pr);
+        out.push(`${pr.created_at || 'unknown'},0,0`);
+        errorCount++;
+        continue;
+    }
+    
+    try {
+        const json = execSync(`gh api "repos/${REPO}/pulls/${pr.number}"`, { 
+            encoding: 'utf8',
+            timeout: 10000  // 10 second timeout per request
+        });
+        const details = JSON.parse(json);
+        const comments = details.comments ?? 0;
+        const reviewComments = details.review_comments ?? 0;
+        
+        out.push(`${pr.created_at},${comments},${reviewComments}`);
+        successCount++;
+    } catch (error) {
+        console.error(`Warning: Failed to fetch PR #${pr.number}:`, error.message);
+        out.push(`${pr.created_at},0,0`);
+        errorCount++;
+    }
+    
+    // Progress reporting and incremental save every 50 PRs
+    if ((i + 1) % 50 === 0) {
+        const progress = Math.round(((i + 1) / prs.length) * 100);
+        process.stderr.write(`  Progress: ${i + 1}/${prs.length} (${progress}%) - Success: ${successCount}, Errors: ${errorCount}\n`);
+        
+        // Incremental save to prevent data loss
+        try {
+            fs.writeFileSync(outPath, out.join('\n'));
+        } catch (saveError) {
+            console.error(`Warning: Could not save incremental progress:`, saveError.message);
+        }
+    }
+}
+
+// Final save
+try {
+    fs.writeFileSync(outPath, out.join('\n'));
+    console.error(`✅ Completed: Wrote prs_details.txt (${prs.length} PRs processed)`);
+    console.error(`   Success: ${successCount}, Errors: ${errorCount}`);
+    
+    if (errorCount > 0) {
+        console.error(`⚠️  Warning: ${errorCount} PRs had errors - comment counts may be incomplete`);
+    }
+} catch (error) {
+    console.error(`❌ Error: Could not write final output:`, error.message);
+    process.exit(1);
+}

package/registry/scripts/productivity/productivity-report.sh

@@ -0,0 +1,147 @@
+#!/bin/bash
+# Generate productivity-report.csv for any GitHub repository
+# Requires: gh CLI (gh auth login), node, jq
+# Usage: bash productivity-report.sh [REPO_OWNER/REPO_NAME]
+
+set -e
+
+# Function to detect repository from git remote
+detect_repository() {
+    if git remote get-url origin >/dev/null 2>&1; then
+        git remote get-url origin | sed 's/.*github\.com[:/]\([^/]*\/[^/]*\)\.git.*/\1/' | sed 's/\.git$//'
+    else
+        echo ""
+    fi
+}
+
+# Function to validate repository format
+validate_repo_format() {
+    local repo="$1"
+    if [[ "$repo" =~ ^[a-zA-Z0-9._-]+/[a-zA-Z0-9._-]+$ ]]; then
+        return 0
+    else
+        return 1
+    fi
+}
+
+# Determine repository
+if [ -n "$1" ]; then
+    # Repository provided as argument
+    REPO="$1"
+    echo "Using repository from argument: $REPO" >&2
+elif [ -n "$REPO_FULL" ]; then
+    # Repository from environment variable
+    REPO="$REPO_FULL"
+    echo "Using repository from REPO_FULL environment variable: $REPO" >&2
+elif [ -n "$REPO_OWNER" ] && [ -n "$REPO_NAME" ]; then
+    # Repository from separate environment variables
+    REPO="$REPO_OWNER/$REPO_NAME"
+    echo "Using repository from REPO_OWNER/REPO_NAME environment variables: $REPO" >&2
+else
+    # Auto-detect from git remote
+    REPO=$(detect_repository)
+    if [ -n "$REPO" ]; then
+        echo "Auto-detected repository from git remote: $REPO" >&2
+    else
+        echo "Error: Could not determine repository." >&2
+        echo "Usage: $0 [REPO_OWNER/REPO_NAME]" >&2
+        echo "Or set environment variables:" >&2
+        echo "  export REPO_FULL=\"owner/repo\"" >&2
+        echo "  export REPO_OWNER=\"owner\" REPO_NAME=\"repo\"" >&2
+        echo "Or run from a git repository with GitHub remote." >&2
+        exit 1
+    fi
+fi
+
+# Validate repository format
+if ! validate_repo_format "$REPO"; then
+    echo "Error: Invalid repository format: $REPO" >&2
+    echo "Expected format: owner/repository-name" >&2
+    exit 1
+fi
+
+# Check GitHub CLI authentication
+if ! gh auth status >/dev/null 2>&1; then
+    echo "Error: GitHub CLI not authenticated." >&2
+    echo "Please run: gh auth login" >&2
+    exit 1
+fi
+
+# Set up directories
+SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
+REPO_ROOT="$(pwd)"
+DATA_DIR="$REPO_ROOT/.productivity-data"
+OUTPUT_DIR="$REPO_ROOT/docs/productivity-report"
+
+echo "Repository: $REPO" >&2
+echo "Data directory: $DATA_DIR" >&2
+echo "Output directory: $OUTPUT_DIR" >&2
+echo "Script directory: $SCRIPT_DIR" >&2
+
+mkdir -p "$DATA_DIR"
+mkdir -p "$OUTPUT_DIR"
+
+# Add .productivity-data to .gitignore if not already present
+GITIGNORE_FILE="$REPO_ROOT/.gitignore"
+if [ -f "$GITIGNORE_FILE" ]; then
+    if ! grep -q "^\.productivity-data/" "$GITIGNORE_FILE" 2>/dev/null; then
+        echo "" >> "$GITIGNORE_FILE"
+        echo "# Productivity report data (generated)" >> "$GITIGNORE_FILE"
+        echo ".productivity-data/" >> "$GITIGNORE_FILE"
+        echo "Added .productivity-data/ to .gitignore" >&2
+    fi
+else
+    echo "# Productivity report data (generated)" > "$GITIGNORE_FILE"
+    echo ".productivity-data/" >> "$GITIGNORE_FILE"
+    echo "Created .gitignore with .productivity-data/ entry" >&2
+fi
+
+echo "Fetching commits..." >&2
+gh api "repos/$REPO/commits?per_page=100" --paginate --jq '.[].commit.author.date' > "$DATA_DIR/commits.txt"
+COMMIT_COUNT=$(wc -l < "$DATA_DIR/commits.txt" | tr -d ' ')
+echo "  $COMMIT_COUNT commits" >&2
+
+echo "Fetching PRs list..." >&2
+gh api "repos/$REPO/pulls?state=all&per_page=100" --paginate --jq '.[] | {number, created_at}' > "$DATA_DIR/prs_list_raw.json"
+PR_COUNT=$(wc -l < "$DATA_DIR/prs_list_raw.json" | tr -d ' ')
+echo "  $PR_COUNT PRs" >&2
+
+echo "Fetching closed issues (non-PR)..." >&2
+gh api "repos/$REPO/issues?state=closed&per_page=100" --paginate --jq '.[] | select(.pull_request == null) | .closed_at' > "$DATA_DIR/issues_closed.txt"
+ISSUE_COUNT=$(wc -l < "$DATA_DIR/issues_closed.txt" | tr -d ' ')
+echo "  $ISSUE_COUNT closed issues" >&2
+
+# Estimate time for PR details fetch
+if [ "$PR_COUNT" -gt 0 ]; then
+    ESTIMATED_MINUTES=$((PR_COUNT * 15 / 10 / 60 + 1))  # ~1.5 sec per PR
+    echo "Fetching PR details (comments + review_comments) - estimated ${ESTIMATED_MINUTES} minutes..." >&2
+else
+    echo "Fetching PR details (comments + review_comments)..." >&2
+fi
+
+# Export repository for the Node.js scripts
+export REPO_FULL="$REPO"
+node "$SCRIPT_DIR/fetch-pr-details.mjs"
+
+echo "Building CSV..." >&2
+node "$SCRIPT_DIR/build-productivity-csv.mjs"
+
+# Check if CSV was created successfully
+OUTPUT_PATTERN="$OUTPUT_DIR/productivity-report-*.csv"
+if ls $OUTPUT_PATTERN 1> /dev/null 2>&1; then
+    LATEST_CSV=$(ls -t $OUTPUT_PATTERN | head -n1)
+    CSV_LINES=$(wc -l < "$LATEST_CSV" | tr -d ' ')
+    FILENAME=$(basename "$LATEST_CSV")
+    echo "Done. Output: docs/productivity-report/$FILENAME ($CSV_LINES lines)" >&2
+    echo "" >&2
+    echo "Summary:" >&2
+    echo "  Repository: $REPO" >&2
+    echo "  Commits: $COMMIT_COUNT" >&2
+    echo "  PRs: $PR_COUNT" >&2
+    echo "  Closed Issues: $ISSUE_COUNT" >&2
+    echo "  Report Lines: $CSV_LINES" >&2
+    echo "  Output File: docs/productivity-report/$FILENAME" >&2
+else
+    echo "Error: No CSV output file was created in $OUTPUT_DIR" >&2
+    exit 1
+fi

package/registry/scripts/profile-server.ts

@@ -196,7 +196,7 @@ async function getSystemInformation(appName: string): Promise<void> {
       try {
         const response = await axios.post(`https://${appName}.scm.azurewebsites.net/api/command`, {
           command: command.cmd,
-          dir: '/home'
+          dir: path.join('/', 'home')
         }, {
           headers: { Authorization: `Bearer ${token}` },
           timeout: 5000