@girardmedia/bootspring 2.0.21 → 2.0.22

package/src/cli/checkpoint-utils.ts

@@ -0,0 +1,236 @@
+/**
+ * Bootspring Checkpoint Utilities
+ * Shared utilities for checkpoint scanning and syncing
+ *
+ * @package bootspring
+ * @module cli/checkpoint-utils
+ */
+
+import * as fs from 'fs';
+import * as path from 'path';
+
+// Type interfaces for JS modules
+interface Config {
+  _projectRoot: string;
+  apiBase?: string | undefined;
+}
+
+interface ConfigModule {
+  load(): Config;
+}
+
+interface AuthModule {
+  getApiKey(): string | null;
+}
+
+interface SessionModule {
+  getCurrentProject(): { id: string } | null;
+}
+
+interface ProjectState {
+  content?: Record<string, unknown> | undefined;
+  business?: Record<string, unknown> | undefined;
+}
+
+interface ProjectStateModule {
+  loadState(projectRoot: string): ProjectState | null;
+}
+
+interface GitHubSyncMetadata {
+  connected?: boolean | undefined;
+}
+
+interface GitHubSyncModule {
+  loadGitHubSyncMetadata(projectRoot: string): GitHubSyncMetadata | null;
+}
+
+interface RawMetrics {
+  categories?: {
+    docs?: { average?: number | undefined } | undefined;
+    security?: { average?: number | undefined } | undefined;
+  } | undefined;
+  metrics?: {
+    test_coverage?: { score?: number | undefined } | undefined;
+    commit_frequency?: { score?: number | undefined } | undefined;
+  } | undefined;
+}
+
+interface MetricsEngineModule {
+  collectMetrics(projectRoot: string, options?: { quiet?: boolean }): Promise<RawMetrics>;
+}
+
+interface FileScanEntry {
+  exists: boolean;
+  size: number;
+  content?: string | undefined;
+}
+
+interface PushResult {
+  success: boolean;
+  reason?: string | undefined;
+  projectType?: string | undefined;
+  progress?: {
+    completed?: number | undefined;
+    total?: number | undefined;
+    percentage?: number | undefined;
+  } | undefined;
+  healthScore?: number | undefined;
+  lastSyncAt?: string | undefined;
+  healthBreakdown?: Record<string, number> | undefined;
+}
+
+interface PushOptions {
+  quiet?: boolean | undefined;
+  autoSync?: boolean | undefined;
+  skipMetrics?: boolean | undefined;
+}
+
+const config = require('../core/config') as ConfigModule;
+const auth = require('../core/auth') as AuthModule;
+const session = require('../core/session') as SessionModule;
+const projectState = require('../core/project-state') as ProjectStateModule;
+
+/**
+ * Scan files for checkpoint evaluation
+ * Returns raw file data - server determines what checkpoints are complete
+ */
+export function scanFilesForCheckpoints(projectRoot: string): Record<string, FileScanEntry> {
+  const fileScan: Record<string, FileScanEntry> = {};
+
+  // List of files to scan (paths are relative to project root)
+  const filesToScan = [
+    'planning/PROJECT_STATE.json',
+    'planning/PRD.md',
+    'planning/TECHNICAL_SPEC.md',
+    'planning/ARCHITECTURE.md',
+    'planning/DATABASE_SCHEMA.md',
+    'planning/API_CONTRACTS.md',
+    'planning/TEST_PLAN.md',
+    'planning/DEPLOYMENT.md',
+    'planning/CONTENT_STRATEGY.md',
+    'planning/EDITORIAL_CALENDAR.md',
+    'planning/STYLE_GUIDE.md',
+    'planning/SEO_PLAN.md',
+    'planning/BUSINESS_PLAN.md',
+    'planning/MARKET_ANALYSIS.md',
+    'planning/COMPETITOR_ANALYSIS.md',
+    'planning/FINANCIAL_MODEL.md',
+    'planning/PITCH_DECK.md',
+    'planning/INVESTOR_LIST.md'
+  ];
+
+  for (const relativePath of filesToScan) {
+    const fullPath = path.join(projectRoot, relativePath);
+    try {
+      if (fs.existsSync(fullPath)) {
+        const stats = fs.statSync(fullPath);
+        const content = fs.readFileSync(fullPath, 'utf-8');
+        fileScan[relativePath] = {
+          exists: true,
+          size: stats.size,
+          // Only include content for files that need pattern matching
+          ...(relativePath === 'planning/DEPLOYMENT.md' && { content })
+        };
+      } else {
+        fileScan[relativePath] = { exists: false, size: 0 };
+      }
+    } catch {
+      fileScan[relativePath] = { exists: false, size: 0 };
+    }
+  }
+
+  return fileScan;
+}
+
+/**
+ * Push checkpoints to dashboard
+ * Sends raw file scan data - server evaluates checkpoints and calculates scores
+ */
+export async function pushCheckpointsToServer(projectRoot: string, options: PushOptions = {}): Promise<PushResult> {
+  const apiKey = auth.getApiKey();
+
+  if (!apiKey) {
+    if (!options.quiet) {
+      throw new Error('Not authenticated. Run: bootspring auth login');
+    }
+    return { success: false, reason: 'not_authenticated' };
+  }
+
+  // Get project ID from session
+  const currentProject = session.getCurrentProject();
+  const projectId = currentProject?.id;
+
+  if (!projectId) {
+    if (!options.quiet) {
+      throw new Error('No project selected. Run: bootspring switch <project>');
+    }
+    return { success: false, reason: 'no_project' };
+  }
+
+  // Scan files - raw data only, no evaluation
+  const fileScan = scanFilesForCheckpoints(projectRoot);
+
+  // Load local state for config values
+  const state = projectState.loadState(projectRoot) || {};
+  const configValues = {
+    content: state.content || {},
+    business: state.business || {}
+  };
+
+  // Check github connection
+  const githubSync = require('../core/github-sync') as GitHubSyncModule;
+  const githubMeta = githubSync.loadGitHubSyncMetadata(projectRoot);
+  const githubConnected = githubMeta?.connected || false;
+
+  // Get raw scores from local collectors (server will weight them)
+  let documentationScore: number | undefined;
+  let securityScore: number | undefined;
+  let testCoverage: number | undefined;
+  let githubActivity: number | undefined;
+
+  if (!options.skipMetrics) {
+    try {
+      const metricsEngine = require('../core/metrics-engine') as MetricsEngineModule;
+      const rawMetrics = await metricsEngine.collectMetrics(projectRoot, { quiet: true });
+      documentationScore = rawMetrics.categories?.docs?.average;
+      securityScore = rawMetrics.categories?.security?.average;
+      testCoverage = rawMetrics.metrics?.test_coverage?.score;
+      githubActivity = rawMetrics.metrics?.commit_frequency?.score;
+    } catch {
+      // Metrics collection is optional
+    }
+  }
+
+  // Send raw data to server for evaluation
+  const cfg = config.load();
+  const apiBase = cfg.apiBase || 'https://bootspring.com';
+  const response = await fetch(`${apiBase}/api/projects/${projectId}/checkpoints/evaluate`, {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json',
+      'x-api-key': apiKey
+    },
+    body: JSON.stringify({
+      fileScan,
+      configValues,
+      githubConnected,
+      githubActivity,
+      documentationScore,
+      securityScore,
+      testCoverage,
+      autoSync: options.autoSync || false
+    }),
+    redirect: 'follow'
+  });
+
+  if (!response.ok) {
+    const error = await response.json().catch(() => ({})) as { error?: string };
+    throw new Error(error.error || `HTTP ${response.status}`);
+  }
+
+  const result = await response.json() as PushResult;
+  return {
+    ...result,
+    success: true
+  };
+}