pgserve 0.1.1

package/.genie/scripts/helpers/detect-markers.js

@@ -0,0 +1,293 @@
+#!/usr/bin/env node
+
+/**
+ * TODO/FIXME/WIP Marker Detector
+ *
+ * Scans files for incomplete work markers:
+ * - TODO, FIXME, XXX, HACK, WIP, TBD
+ * - Placeholder text patterns
+ *
+ * Usage:
+ *   node detect-markers.js [path]
+ *   (defaults to current directory if no path provided)
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+// Marker patterns
+const MARKERS = {
+  todo: /\bTODO\b:?/gi,
+  fixme: /\bFIXME\b:?/gi,
+  xxx: /\bXXX\b:?/gi,
+  hack: /\bHACK\b:?/gi,
+  wip: /\bWIP\b:?/gi,
+  tbd: /\bTBD\b:?/gi,
+};
+
+const PLACEHOLDER_PATTERNS = [
+  /coming soon/gi,
+  /to be documented/gi,
+  /fill this in later/gi,
+  /\[placeholder\]/gi,
+  /lorem ipsum/gi,
+  /TODO: write this section/gi,
+];
+
+// Git conflict markers (CRITICAL)
+const CONFLICT_MARKERS = [
+  /^<<<<<<< /m,
+  /^=======/m,
+  /^>>>>>>> /m,
+  /^\|\|\|\|\|\|\| merged common ancestors/m,
+];
+
+// Configuration
+const EXCLUDE_PATTERNS = [
+  'node_modules',
+  '.git',
+  'dist',
+  'build',
+  'coverage',
+  '/backups/',
+  '.min.js',
+  '.bundle.js',
+];
+
+// File extensions to scan
+const SCAN_EXTENSIONS = ['.md', '.js', '.ts', '.jsx', '.tsx', '.json', '.yaml', '.yml'];
+
+// Results
+const results = {
+  totalFiles: 0,
+  scannedFiles: 0,
+  issues: [],
+  summary: {
+    markers: {},
+    placeholders: 0,
+    conflicts: 0,
+  },
+};
+
+/**
+ * Should scan this file?
+ */
+function shouldScan(filePath) {
+  // Check exclusions
+  if (EXCLUDE_PATTERNS.some(pattern => filePath.includes(pattern))) {
+    return false;
+  }
+
+  // Check extension
+  const ext = path.extname(filePath);
+  return SCAN_EXTENSIONS.includes(ext);
+}
+
+/**
+ * Check if line is inside code block (markdown)
+ */
+function isInCodeBlock(lines, lineIndex) {
+  let inCodeBlock = false;
+  for (let i = 0; i < lineIndex; i++) {
+    if (lines[i].trim().startsWith('```')) {
+      inCodeBlock = !inCodeBlock;
+    }
+  }
+  return inCodeBlock;
+}
+
+/**
+ * Scan single file
+ */
+function scanFile(filePath) {
+  results.totalFiles++;
+
+  if (!shouldScan(filePath)) {
+    return;
+  }
+
+  try {
+    const content = fs.readFileSync(filePath, 'utf-8');
+    const lines = content.split('\n');
+    const isMarkdown = filePath.endsWith('.md');
+
+    results.scannedFiles++;
+
+    lines.forEach((line, index) => {
+      const lineNum = index + 1;
+
+      // Skip code blocks in markdown (intentional examples)
+      if (isMarkdown && isInCodeBlock(lines, index)) {
+        return;
+      }
+
+      // Check for git conflict markers (CRITICAL)
+      CONFLICT_MARKERS.forEach(pattern => {
+        if (pattern.test(line)) {
+          results.issues.push({
+            file: filePath,
+            line: lineNum,
+            type: 'conflict_marker',
+            severity: 'critical',
+            content: line.trim(),
+            message: 'Unresolved git merge conflict marker',
+          });
+          results.summary.conflicts++;
+        }
+      });
+
+      // Check for TODO/FIXME markers
+      Object.entries(MARKERS).forEach(([type, pattern]) => {
+        const match = line.match(pattern);
+        if (match) {
+          results.issues.push({
+            file: filePath,
+            line: lineNum,
+            type: `marker_${type}`,
+            severity: 'warning',
+            content: line.trim(),
+            message: `${type.toUpperCase()} marker found`,
+          });
+          results.summary.markers[type] = (results.summary.markers[type] || 0) + 1;
+        }
+      });
+
+      // Check for placeholder text
+      PLACEHOLDER_PATTERNS.forEach(pattern => {
+        const match = line.match(pattern);
+        if (match) {
+          results.issues.push({
+            file: filePath,
+            line: lineNum,
+            type: 'placeholder',
+            severity: 'warning',
+            content: line.trim(),
+            message: `Placeholder text: "${match[0]}"`,
+          });
+          results.summary.placeholders++;
+        }
+      });
+    });
+
+  } catch (err) {
+    console.error(`Error scanning ${filePath}: ${err.message}`);
+  }
+}
+
+/**
+ * Recursively scan directory
+ */
+function scanDirectory(dir) {
+  const entries = fs.readdirSync(dir, { withFileTypes: true });
+
+  for (const entry of entries) {
+    const fullPath = path.join(dir, entry.name);
+
+    if (entry.isDirectory()) {
+      scanDirectory(fullPath);
+    } else if (entry.isFile()) {
+      scanFile(fullPath);
+    }
+  }
+}
+
+/**
+ * Generate report
+ */
+function generateReport() {
+  console.log('\n=== TODO/FIXME/Placeholder Detection Report ===\n');
+
+  console.log(`Total files: ${results.totalFiles}`);
+  console.log(`Scanned: ${results.scannedFiles}`);
+  console.log(`Issues found: ${results.issues.length}\n`);
+
+  if (results.issues.length === 0) {
+    console.log('✅ No markers or placeholders found!\n');
+    return 0;
+  }
+
+  // Group by severity
+  const critical = results.issues.filter(i => i.severity === 'critical');
+  const warnings = results.issues.filter(i => i.severity === 'warning');
+
+  // Show critical first
+  if (critical.length > 0) {
+    console.log(`🔴 CRITICAL (${critical.length}):\n`);
+    critical.forEach(issue => {
+      console.log(`  ${issue.file}:${issue.line}`);
+      console.log(`    ${issue.message}`);
+      console.log(`    Content: ${issue.content}`);
+      console.log('');
+    });
+  }
+
+  // Show warnings
+  if (warnings.length > 0) {
+    console.log(`⚠️  WARNINGS (${warnings.length}):\n`);
+
+    // Group by type for cleaner output
+    const byType = {};
+    warnings.forEach(issue => {
+      if (!byType[issue.type]) byType[issue.type] = [];
+      byType[issue.type].push(issue);
+    });
+
+    Object.entries(byType).forEach(([type, issues]) => {
+      console.log(`  ${type.toUpperCase()} (${issues.length}):`);
+      issues.forEach(issue => {
+        console.log(`    ${issue.file}:${issue.line} - ${issue.content.substring(0, 80)}`);
+      });
+      console.log('');
+    });
+  }
+
+  // Summary
+  console.log('\n=== Summary ===\n');
+
+  if (results.summary.conflicts > 0) {
+    console.log(`  🔴 Conflict markers: ${results.summary.conflicts} (CRITICAL - FIX IMMEDIATELY)`);
+  }
+
+  const totalMarkers = Object.values(results.summary.markers).reduce((a, b) => a + b, 0);
+  if (totalMarkers > 0) {
+    console.log(`  ⚠️  TODO/FIXME markers: ${totalMarkers}`);
+    Object.entries(results.summary.markers).forEach(([type, count]) => {
+      console.log(`      ${type.toUpperCase()}: ${count}`);
+    });
+  }
+
+  if (results.summary.placeholders > 0) {
+    console.log(`  ⚠️  Placeholder text: ${results.summary.placeholders}`);
+  }
+
+  console.log('');
+
+  // Exit code: 1 if critical issues found, 0 otherwise
+  return critical.length > 0 ? 1 : 0;
+}
+
+/**
+ * Main
+ */
+function main() {
+  const targetPath = process.argv[2] || '.';
+
+  if (!fs.existsSync(targetPath)) {
+    console.error(`Error: Path not found: ${targetPath}`);
+    process.exit(1);
+  }
+
+  console.log(`Scanning: ${targetPath}\n`);
+
+  const stat = fs.statSync(targetPath);
+  if (stat.isDirectory()) {
+    scanDirectory(targetPath);
+  } else {
+    scanFile(targetPath);
+  }
+
+  const exitCode = generateReport();
+  process.exit(exitCode);
+}
+
+main();

package/.genie/scripts/helpers/detect-todos.js

@@ -0,0 +1,267 @@
+#!/usr/bin/env node
+
+/**
+ * TODO/FIXME Marker Detection
+ *
+ * Scans markdown files for incomplete work markers:
+ * - TODO, FIXME, XXX, HACK, TBD, WIP
+ * - "Coming soon", placeholder text
+ * - Git merge conflict markers
+ *
+ * Usage:
+ *   node detect-todos.js [path]
+ *   (defaults to .genie/ if no path provided)
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+// Marker patterns (case-insensitive)
+const MARKERS = {
+  todo: /\bTODO:?/i,
+  fixme: /\bFIXME:?/i,
+  xxx: /\bXXX:?/i,
+  hack: /\bHACK:?/i,
+  tbd: /\bTBD:?/i,
+  wip: /\bWIP:?/i,
+};
+
+const PLACEHOLDER_PATTERNS = [
+  /\bcoming soon\b/i,
+  /\bto be documented\b/i,
+  /\bfill this in later\b/i,
+  /\[placeholder\]/i,
+  /\blorem ipsum\b/i,
+  /\bTODO:\s*write this section\b/i,
+];
+
+const CONFLICT_MARKERS = [
+  /^<<<<<<< /m,
+  /^=======$/m,
+  /^>>>>>>> /m,
+  /^\|\|\|\|\|\|\| /m,
+];
+
+// Results tracking
+const results = {
+  totalFiles: 0,
+  scannedFiles: 0,
+  issues: [],
+  skipped: [],
+};
+
+/**
+ * Check if file should be scanned
+ */
+function shouldScan(filePath) {
+  const excludePatterns = [
+    'node_modules',
+    '.git',
+    'dist',
+    'build',
+    'coverage',
+    '/backups/',
+    'detect-todos.js', // Don't scan self
+    'GARBAGE-DETECTION-IDEAS.md', // Ideas doc has intentional TODOs
+  ];
+
+  return !excludePatterns.some(pattern => filePath.includes(pattern));
+}
+
+/**
+ * Check if line is inside code block
+ */
+function isInCodeBlock(lines, lineIndex) {
+  let inCodeBlock = false;
+  for (let i = 0; i < lineIndex; i++) {
+    if (lines[i].trim().startsWith('```')) {
+      inCodeBlock = !inCodeBlock;
+    }
+  }
+  return inCodeBlock;
+}
+
+/**
+ * Scan file for markers
+ */
+function scanFile(filePath) {
+  results.totalFiles++;
+
+  if (!shouldScan(filePath)) {
+    results.skipped.push({ file: filePath, reason: 'Excluded path' });
+    return;
+  }
+
+  try {
+    const content = fs.readFileSync(filePath, 'utf-8');
+    const lines = content.split('\n');
+
+    results.scannedFiles++;
+
+    lines.forEach((line, index) => {
+      const lineNum = index + 1;
+      const inCodeBlock = isInCodeBlock(lines, index);
+
+      // Skip code blocks for markers (but not conflict markers)
+      if (!inCodeBlock) {
+        // Check TODO/FIXME/etc markers
+        for (const [type, pattern] of Object.entries(MARKERS)) {
+          if (pattern.test(line)) {
+            results.issues.push({
+              file: filePath,
+              line: lineNum,
+              type: `marker_${type}`,
+              severity: 'warning',
+              content: line.trim(),
+              message: `${type.toUpperCase()} marker found`,
+              suggestion: 'Complete the work or remove the marker',
+            });
+          }
+        }
+
+        // Check placeholder patterns
+        for (const pattern of PLACEHOLDER_PATTERNS) {
+          if (pattern.test(line)) {
+            results.issues.push({
+              file: filePath,
+              line: lineNum,
+              type: 'placeholder_text',
+              severity: 'warning',
+              content: line.trim(),
+              message: 'Placeholder text found',
+              suggestion: 'Complete the content or remove the placeholder',
+            });
+            break; // Only report first match per line
+          }
+        }
+      }
+
+      // Check conflict markers (even in code blocks)
+      for (const pattern of CONFLICT_MARKERS) {
+        if (pattern.test(line)) {
+          results.issues.push({
+            file: filePath,
+            line: lineNum,
+            type: 'merge_conflict',
+            severity: 'error',
+            content: line.trim(),
+            message: 'Git merge conflict marker found',
+            suggestion: 'Resolve the conflict immediately',
+          });
+          break;
+        }
+      }
+    });
+
+  } catch (err) {
+    results.issues.push({
+      file: filePath,
+      type: 'read_error',
+      message: `Failed to read file: ${err.message}`,
+      severity: 'error',
+    });
+  }
+}
+
+/**
+ * Recursively scan directory
+ */
+function scanDirectory(dir) {
+  const entries = fs.readdirSync(dir, { withFileTypes: true });
+
+  for (const entry of entries) {
+    const fullPath = path.join(dir, entry.name);
+
+    if (entry.isDirectory()) {
+      scanDirectory(fullPath);
+    } else if (entry.isFile() && entry.name.endsWith('.md')) {
+      scanFile(fullPath);
+    }
+  }
+}
+
+/**
+ * Generate report
+ */
+function generateReport() {
+  console.log('\n=== TODO/FIXME Detection Report ===\n');
+
+  console.log(`Total files: ${results.totalFiles}`);
+  console.log(`Scanned: ${results.scannedFiles}`);
+  console.log(`Issues found: ${results.issues.length}`);
+  console.log(`Skipped: ${results.skipped.length}\n`);
+
+  if (results.issues.length === 0) {
+    console.log('✅ No TODO/FIXME markers found!\n');
+    return 0;
+  }
+
+  // Group by severity
+  const errors = results.issues.filter(i => i.severity === 'error');
+  const warnings = results.issues.filter(i => i.severity === 'warning');
+
+  if (errors.length > 0) {
+    console.log(`🔴 ERRORS (${errors.length}):\n`);
+    errors.forEach(issue => {
+      console.log(`  ${issue.file}:${issue.line || '?'}`);
+      console.log(`    Type: ${issue.type}`);
+      console.log(`    Message: ${issue.message}`);
+      console.log(`    Content: ${issue.content}`);
+      console.log(`    Suggestion: ${issue.suggestion}`);
+      console.log('');
+    });
+  }
+
+  if (warnings.length > 0) {
+    console.log(`⚠️  WARNINGS (${warnings.length}):\n`);
+    warnings.forEach(issue => {
+      console.log(`  ${issue.file}:${issue.line || '?'}`);
+      console.log(`    Type: ${issue.type}`);
+      console.log(`    Content: ${issue.content}`);
+      console.log('');
+    });
+  }
+
+  // Summary by type
+  console.log('\n=== Summary by Type ===\n');
+  const byType = {};
+  results.issues.forEach(issue => {
+    byType[issue.type] = (byType[issue.type] || 0) + 1;
+  });
+
+  Object.entries(byType).forEach(([type, count]) => {
+    console.log(`  ${type}: ${count}`);
+  });
+
+  console.log('');
+  return errors.length > 0 ? 1 : 0;
+}
+
+/**
+ * Main
+ */
+function main() {
+  const targetPath = process.argv[2] || '.genie';
+
+  if (!fs.existsSync(targetPath)) {
+    console.error(`Error: Path not found: ${targetPath}`);
+    process.exit(1);
+  }
+
+  console.log(`Scanning: ${targetPath}\n`);
+
+  const stat = fs.statSync(targetPath);
+  if (stat.isDirectory()) {
+    scanDirectory(targetPath);
+  } else if (targetPath.endsWith('.md')) {
+    scanFile(targetPath);
+  } else {
+    console.error('Error: Target must be a directory or .md file');
+    process.exit(1);
+  }
+
+  const exitCode = generateReport();
+  process.exit(exitCode);
+}
+
+main();

package/.genie/scripts/helpers/detect-unlabeled-blocks.js

@@ -0,0 +1,135 @@
+#!/usr/bin/env node
+
+/**
+ * Detect Unlabeled Code Blocks Helper
+ *
+ * Find fenced code blocks without language identifiers.
+ * Detects ``` without language specification (should be ```bash, ```typescript, etc.)
+ *
+ * Usage:
+ *   node detect-unlabeled-blocks.js <file-path>     # Check single file
+ *   node detect-unlabeled-blocks.js <directory>     # Check all .md files recursively
+ *
+ * Output:
+ *   <file>:<line>: Unlabeled code block (missing language identifier)
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+/**
+ * Detect unlabeled code blocks in file content
+ * Returns: [{ line, content }]
+ */
+function detectUnlabeledBlocks(content) {
+  const lines = content.split('\n');
+  const issues = [];
+
+  lines.forEach((line, idx) => {
+    // Match ``` at start of line with optional whitespace
+    // But NOT ```language or ``` followed by text on same line
+    if (/^```\s*$/.test(line.trim())) {
+      issues.push({
+        line: idx + 1,
+        content: line.trim(),
+      });
+    }
+  });
+
+  return issues;
+}
+
+/**
+ * Check single file
+ */
+function checkFile(filePath) {
+  try {
+    const content = fs.readFileSync(filePath, 'utf-8');
+    const issues = detectUnlabeledBlocks(content);
+
+    return issues.map(issue => ({
+      file: filePath,
+      line: issue.line,
+      content: issue.content,
+    }));
+  } catch (err) {
+    return [{ file: filePath, error: `Failed to read file: ${err.message}` }];
+  }
+}
+
+/**
+ * Check all .md files in directory
+ */
+function checkDirectory(dirPath) {
+  const allIssues = [];
+
+  function scanDir(dir) {
+    const entries = fs.readdirSync(dir, { withFileTypes: true });
+
+    entries.forEach(entry => {
+      const fullPath = path.join(dir, entry.name);
+
+      if (entry.isDirectory() && !entry.name.startsWith('.')) {
+        scanDir(fullPath);
+      } else if (entry.isFile() && entry.name.endsWith('.md')) {
+        const issues = checkFile(fullPath);
+        allIssues.push(...issues);
+      }
+    });
+  }
+
+  scanDir(dirPath);
+  return allIssues;
+}
+
+/**
+ * Main
+ */
+function main() {
+  const args = process.argv.slice(2);
+
+  if (args.length === 0) {
+    console.error(`
+Usage:
+  node detect-unlabeled-blocks.js <file-path>     # Check single file
+  node detect-unlabeled-blocks.js <directory>     # Check all .md files recursively
+
+Output:
+  <file>:<line>: Unlabeled code block (missing language identifier)
+
+Exit code:
+  0 = All code blocks labeled
+  1 = Unlabeled blocks found
+`);
+    process.exit(1);
+  }
+
+  const target = args[0];
+
+  if (!fs.existsSync(target)) {
+    console.error(`Error: Path not found: ${target}`);
+    process.exit(1);
+  }
+
+  const stat = fs.statSync(target);
+  const issues = stat.isDirectory()
+    ? checkDirectory(target)
+    : checkFile(target);
+
+  if (issues.length === 0) {
+    console.log('All code blocks properly labeled');
+    process.exit(0);
+  }
+
+  issues.forEach(issue => {
+    if (issue.line) {
+      console.log(`${issue.file}:${issue.line}: Unlabeled code block (missing language identifier)`);
+    } else {
+      console.log(`${issue.file}: ${issue.error}`);
+    }
+  });
+
+  process.exit(1);
+}
+
+main();