edsger 0.2.2 → 0.2.4

package/dist/services/audit-logs.js

@@ -0,0 +1,115 @@
+/**
+ * Feature Audit Logs Service
+ * Provides functions to log feature lifecycle events to the database
+ */
+import { callMcpEndpoint } from '../api/mcp-client.js';
+import { logInfo, logError } from '../utils/logger.js';
+/**
+ * Log a phase event (start, completion, or failure)
+ */
+export async function logFeaturePhaseEvent(mcpServerUrl, mcpToken, params, verbose) {
+    try {
+        const result = await callMcpEndpoint(mcpServerUrl, mcpToken, 'feature_audit_logs/create', {
+            feature_id: params.featureId,
+            event_type: params.eventType,
+            phase: params.phase,
+            source: 'pipeline',
+            result: params.result || 'info',
+            metadata: params.metadata || {},
+            error_message: params.errorMessage || null,
+        });
+        if (verbose) {
+            logInfo(`✅ Logged ${params.eventType} for phase ${params.phase}`);
+        }
+        return result?.id || null;
+    }
+    catch (error) {
+        // Always log errors, not just in verbose mode
+        logError(`Failed to log phase event: ${error instanceof Error ? error.message : String(error)}`);
+        if (verbose && error instanceof Error && error.stack) {
+            logError(`Stack trace: ${error.stack}`);
+        }
+        return null;
+    }
+}
+/**
+ * Log a checklist validation event
+ */
+export async function logFeatureChecklistEvent(mcpServerUrl, mcpToken, params, verbose) {
+    try {
+        const result = await callMcpEndpoint(mcpServerUrl, mcpToken, 'feature_audit_logs/create', {
+            feature_id: params.featureId,
+            event_type: params.eventType,
+            source: 'pipeline',
+            result: params.result || 'success',
+            metadata: {
+                checklist_id: params.checklistId,
+                ...(params.metadata || {}),
+            },
+        });
+        if (verbose) {
+            logInfo(`✅ Logged ${params.eventType} for checklist ${params.checklistId}`);
+        }
+        return result?.id || null;
+    }
+    catch (error) {
+        // Always log errors, not just in verbose mode
+        logError(`Failed to log checklist event: ${error instanceof Error ? error.message : String(error)}`);
+        if (verbose && error instanceof Error && error.stack) {
+            logError(`Stack trace: ${error.stack}`);
+        }
+        return null;
+    }
+}
+/**
+ * Log a verification event (dual-agent verification result)
+ */
+export async function logFeatureVerificationEvent(mcpServerUrl, mcpToken, params, verbose) {
+    try {
+        const eventType = params.result === 'success'
+            ? 'verification_passed'
+            : 'verification_failed';
+        const result = await callMcpEndpoint(mcpServerUrl, mcpToken, 'feature_audit_logs/create', {
+            feature_id: params.featureId,
+            event_type: eventType,
+            phase: params.phase,
+            source: 'pipeline',
+            result: params.result,
+            metadata: {
+                iteration: params.iteration,
+                ...params.verificationData,
+            },
+        });
+        if (verbose) {
+            logInfo(`✅ Logged verification ${params.result} for phase ${params.phase} (iteration ${params.iteration})`);
+        }
+        return result?.id || null;
+    }
+    catch (error) {
+        // Always log errors, not just in verbose mode
+        logError(`Failed to log verification event: ${error instanceof Error ? error.message : String(error)}`);
+        if (verbose && error instanceof Error && error.stack) {
+            logError(`Stack trace: ${error.stack}`);
+        }
+        return null;
+    }
+}
+/**
+ * Get feature timeline (all audit logs)
+ */
+export async function getFeatureTimeline(mcpServerUrl, mcpToken, featureId, verbose) {
+    try {
+        const result = await callMcpEndpoint(mcpServerUrl, mcpToken, 'feature_audit_logs/list', {
+            feature_id: featureId,
+        });
+        return result?.logs || [];
+    }
+    catch (error) {
+        // Always log errors, not just in verbose mode
+        logError(`Failed to get feature timeline: ${error instanceof Error ? error.message : String(error)}`);
+        if (verbose && error instanceof Error && error.stack) {
+            logError(`Stack trace: ${error.stack}`);
+        }
+        return [];
+    }
+}

package/dist/services/checklist.d.ts

@@ -2,6 +2,7 @@
  * Checklist service for pipeline integration
  */
 import { PipelinePhaseOptions } from '../types/pipeline.js';
+export type { PipelinePhaseOptions };
 export interface ChecklistItem {
     id: string;
     title: string;

package/dist/types/index.d.ts

@@ -30,6 +30,7 @@ export interface CliOptions {
     implement?: string;
     test?: string;
     workflow?: boolean;
+    refactor?: boolean;
 }
 export type ReviewSeverity = 'error' | 'warning';
 export type ExitCode = 0 | 1;
@@ -55,6 +56,24 @@ export interface FeatureAnalysisResult {
             value?: any;
             notes?: string;
         }>;
+        verification_result?: {
+            all_verified: boolean;
+            total_items: number;
+            confirmed_count: number;
+            rejected_count: number;
+            uncertain_count: number;
+            item_verifications: Array<{
+                checklist_item_id: string;
+                is_satisfied: boolean;
+                verification_status: 'confirmed' | 'rejected' | 'uncertain';
+                verification_reason: string;
+                concerns?: string[];
+                improvement_suggestions?: string[];
+            }>;
+            summary: string;
+            overall_suggestions?: string[];
+        };
+        iterations?: number;
     };
 }
 export interface FeatureData {

package/dist/utils/image-downloader.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Downloaded image info
+ */
+export interface DownloadedImage {
+    url: string;
+    localPath: string;
+    alt: string;
+}
+/**
+ * Set current feature ID for image downloads
+ * Should be called at the start of pipeline execution
+ */
+export declare function setCurrentFeatureId(featureId: string): void;
+/**
+ * Reset image cache (useful for testing)
+ */
+export declare function resetImageCache(): void;
+/**
+ * Download images from URLs to temporary directory for Claude Code to read
+ * Uses cache to avoid downloading same image multiple times
+ *
+ * @param markdown - Markdown content with image URLs
+ * @param featureId - Feature ID for directory naming
+ */
+export declare function downloadImagesForClaudeCode(markdown: string, featureId?: string): Promise<{
+    processedMarkdown: string;
+    downloadedImages: DownloadedImage[];
+}>;
+/**
+ * Clean markdown by removing width attributes
+ */
+export declare function cleanMarkdownForClaudeCode(markdown: string): string;

package/dist/utils/image-downloader.js

@@ -0,0 +1,144 @@
+import { createWriteStream } from 'fs';
+import { mkdir, access } from 'fs/promises';
+import { tmpdir } from 'os';
+import { join } from 'path';
+import { pipeline } from 'stream/promises';
+import { createHash } from 'crypto';
+import { logInfo, logError } from './logger.js';
+// Cache for downloaded images in current session
+// Key: image URL, Value: local path
+const imageCache = new Map();
+// Current feature ID for directory naming
+let currentFeatureId = null;
+/**
+ * Generate hash from URL to use as filename
+ * This ensures same URL always maps to same file
+ */
+function hashUrl(url) {
+    return createHash('md5').update(url).digest('hex');
+}
+/**
+ * Get or create temp directory for current feature
+ */
+function getTempDir(featureId) {
+    return join(tmpdir(), 'claude-code-images', `feature-${featureId}`);
+}
+/**
+ * Set current feature ID for image downloads
+ * Should be called at the start of pipeline execution
+ */
+export function setCurrentFeatureId(featureId) {
+    if (currentFeatureId !== featureId) {
+        // Clear cache when switching to different feature
+        imageCache.clear();
+        currentFeatureId = featureId;
+    }
+}
+/**
+ * Reset image cache (useful for testing)
+ */
+export function resetImageCache() {
+    imageCache.clear();
+    currentFeatureId = null;
+}
+/**
+ * Download images from URLs to temporary directory for Claude Code to read
+ * Uses cache to avoid downloading same image multiple times
+ *
+ * @param markdown - Markdown content with image URLs
+ * @param featureId - Feature ID for directory naming
+ */
+export async function downloadImagesForClaudeCode(markdown, featureId) {
+    if (!markdown) {
+        return { processedMarkdown: markdown, downloadedImages: [] };
+    }
+    // Use provided featureId or fall back to currentFeatureId or timestamp
+    const effectiveFeatureId = featureId || currentFeatureId || Date.now().toString();
+    // Extract all image URLs from markdown
+    const imageRegex = /!\[([^\]]*)\]\(([^)]+)\)(?:\{width=\d+\})?/g;
+    const matches = Array.from(markdown.matchAll(imageRegex));
+    if (matches.length === 0) {
+        return { processedMarkdown: markdown, downloadedImages: [] };
+    }
+    // Create temp directory for this feature
+    const tempDir = getTempDir(effectiveFeatureId);
+    await mkdir(tempDir, { recursive: true });
+    const downloadedImages = [];
+    let processedMarkdown = markdown;
+    // Download each image (or use cached version)
+    for (let i = 0; i < matches.length; i++) {
+        const match = matches[i];
+        const alt = match[1] || '';
+        const url = match[2];
+        try {
+            // Check if image is already cached
+            let localPath = imageCache.get(url);
+            if (localPath) {
+                // Verify cached file still exists
+                try {
+                    await access(localPath);
+                    logInfo(`Using cached image: ${url}`);
+                }
+                catch {
+                    // Cached file no longer exists, remove from cache
+                    imageCache.delete(url);
+                    localPath = undefined;
+                }
+            }
+            if (!localPath) {
+                // Download image
+                logInfo(`Downloading image ${i + 1}/${matches.length}: ${url}`);
+                const response = await fetch(url);
+                if (!response.ok) {
+                    logError(`Failed to download image: ${response.statusText}`);
+                    continue;
+                }
+                // Determine file extension from URL or content-type
+                let extension = 'png';
+                const urlExt = url.split('.').pop()?.toLowerCase();
+                if (urlExt && ['jpg', 'jpeg', 'png', 'gif', 'webp'].includes(urlExt)) {
+                    extension = urlExt;
+                }
+                else {
+                    const contentType = response.headers.get('content-type');
+                    if (contentType?.includes('jpeg'))
+                        extension = 'jpg';
+                    else if (contentType?.includes('png'))
+                        extension = 'png';
+                    else if (contentType?.includes('gif'))
+                        extension = 'gif';
+                    else if (contentType?.includes('webp'))
+                        extension = 'webp';
+                }
+                // Use hash of URL as filename (ensures same URL = same file)
+                const urlHash = hashUrl(url);
+                const filename = `${urlHash}.${extension}`;
+                localPath = join(tempDir, filename);
+                // Use Node.js streams to save the file
+                const fileStream = createWriteStream(localPath);
+                if (response.body) {
+                    await pipeline(response.body, fileStream);
+                }
+                // Cache the downloaded image
+                imageCache.set(url, localPath);
+                logInfo(`Downloaded to: ${localPath}`);
+            }
+            downloadedImages.push({ url, localPath, alt });
+            // Replace URL with local path in markdown
+            processedMarkdown = processedMarkdown.replace(match[0], `![${alt}](${localPath})`);
+        }
+        catch (error) {
+            logError(`Failed to download image ${url}: ${error}`);
+        }
+    }
+    return { processedMarkdown, downloadedImages };
+}
+/**
+ * Clean markdown by removing width attributes
+ */
+export function cleanMarkdownForClaudeCode(markdown) {
+    if (!markdown)
+        return markdown;
+    // Remove {width=600} syntax to keep pure markdown
+    return markdown.replace(/!\[([^\]]*)\]\(([^)]+)\)\{width=\d+\}/g, '![$1]($2)');
+}

package/dist/workflow-runner/executors/phase-executor.js

@@ -4,10 +4,13 @@
 import { updateFeatureStatusForPhase } from '../../api/features/index.js';
 import { phaseConfigs } from '../config/phase-configs.js';
 import { getChecklistsForPhase, validateChecklistsForPhase, validateRequiredChecklistResults, processChecklistResultsFromResponse, processChecklistItemResultsFromResponse, } from '../../services/checklist.js';
+import { logFeaturePhaseEvent } from '../../services/audit-logs.js';
 // Higher-order function for phase execution
 export const createPhaseRunner = (phaseConfig) => async (options, config) => {
     const { featureId, mcpServerUrl, mcpToken, verbose } = options;
     const { name, checkRequirements, execute, requirementsError } = phaseConfig;
+    // Track phase duration for logging
+    const phaseStartTime = Date.now();
     try {
         // Check requirements
         const hasRequirements = await checkRequirements();
@@ -24,6 +27,16 @@ export const createPhaseRunner = (phaseConfig) => async (options, config) => {
         if (verbose) {
             console.log(`🎯 Starting ${name} for: ${featureId}`);
         }
+        // Log phase start
+        await logFeaturePhaseEvent(mcpServerUrl, mcpToken, {
+            featureId,
+            eventType: 'phase_started',
+            phase: name.replace(/-/g, '_'),
+            result: 'info',
+            metadata: {
+                timestamp: new Date().toISOString(),
+            },
+        }, verbose);
         // Fetch checklists for this phase as context
         let checklistContext = null;
         try {
@@ -42,18 +55,6 @@ export const createPhaseRunner = (phaseConfig) => async (options, config) => {
         }
         // Execute the phase with checklist context
         const result = await execute(options, config, checklistContext);
-        console.log({
-            result,
-        });
-        console.log({
-            status: result.status,
-        });
-        console.log({
-            data: result.data,
-        });
-        console.log({
-            checklist_item_results: result.data?.checklist_item_results,
-        });
         // Process checklist results from phase response if phase was successful
         if (result.status === 'success') {
             try {
@@ -154,6 +155,35 @@ export const createPhaseRunner = (phaseConfig) => async (options, config) => {
                 };
             }
         }
+        // Log phase completion
+        const phaseEndTime = Date.now();
+        const phaseDuration = phaseEndTime - phaseStartTime;
+        if (result.status === 'success') {
+            await logFeaturePhaseEvent(mcpServerUrl, mcpToken, {
+                featureId,
+                eventType: 'phase_completed',
+                phase: name.replace(/-/g, '_'),
+                result: 'success',
+                metadata: {
+                    duration_ms: phaseDuration,
+                    iterations: result.data?.iterations,
+                    artifacts: result.data,
+                    checklist_validation: checklistValidation,
+                },
+            }, verbose);
+        }
+        else {
+            await logFeaturePhaseEvent(mcpServerUrl, mcpToken, {
+                featureId,
+                eventType: 'phase_failed',
+                phase: name.replace(/-/g, '_'),
+                result: 'error',
+                metadata: {
+                    duration_ms: phaseDuration,
+                },
+                errorMessage: result.summary || 'Phase execution failed',
+            }, verbose);
+        }
         return {
             featureId,
             phase: name,
@@ -169,6 +199,20 @@ export const createPhaseRunner = (phaseConfig) => async (options, config) => {
         };
     }
     catch (error) {
+        // Log phase failure for exceptions
+        const phaseEndTime = Date.now();
+        const phaseDuration = phaseEndTime - phaseStartTime;
+        await logFeaturePhaseEvent(mcpServerUrl, mcpToken, {
+            featureId,
+            eventType: 'phase_failed',
+            phase: name.replace(/-/g, '_'),
+            result: 'error',
+            metadata: {
+                duration_ms: phaseDuration,
+                error_type: 'exception',
+            },
+            errorMessage: error instanceof Error ? error.message : String(error),
+        }, verbose);
         return {
             featureId,
             phase: name,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "edsger",
-  "version": "0.2.2",
+  "version": "0.2.4",
   "type": "module",
   "main": "dist/index.js",
   "bin": {

package/dist/api/features.d.ts

@@ -1,100 +0,0 @@
-export interface FeatureInfo {
-    id: string;
-    name: string;
-    description?: string;
-    technical_design?: string;
-    status: string;
-    product_id: string;
-    created_at?: string;
-    updated_at?: string;
-}
-/**
- * Get feature details by ID
- */
-export declare function getFeature(mcpServerUrl: string, mcpToken: string, featureId: string, verbose?: boolean): Promise<FeatureInfo>;
-/**
- * Update feature with new data
- */
-export declare function updateFeature(mcpServerUrl: string, mcpToken: string, featureId: string, updates: {
-    technical_design?: string;
-    status?: string;
-    pull_request_url?: string;
-}, verbose?: boolean): Promise<boolean>;
-/**
- * Update technical design for a feature
- */
-export declare function updateTechnicalDesign(mcpServerUrl: string, mcpToken: string, featureId: string, technicalDesign: string, verbose?: boolean): Promise<boolean>;
-/**
- * Update feature status
- */
-export declare function updateFeatureStatus(mcpServerUrl: string, mcpToken: string, featureId: string, status: string, verbose?: boolean): Promise<boolean>;
-export interface UserStory {
-    id: string;
-    title: string;
-    description: string;
-    status: string;
-    created_at?: string;
-    updated_at?: string;
-    [key: string]: any;
-}
-/**
- * Get user stories for a feature
- */
-export declare function getUserStories(mcpServerUrl: string, mcpToken: string, featureId: string, verbose?: boolean): Promise<UserStory[]>;
-/**
- * Create a new user story for a feature
- */
-export declare function createUserStory(mcpServerUrl: string, mcpToken: string, featureId: string, userStory: {
-    title: string;
-    description: string;
-    status?: string;
-}, verbose?: boolean): Promise<boolean>;
-/**
- * Create multiple user stories for a feature
- */
-export declare function createUserStories(mcpServerUrl: string, mcpToken: string, featureId: string, userStories: Array<{
-    title: string;
-    description: string;
-    status?: string;
-}>, verbose?: boolean): Promise<boolean>;
-export interface TestCase {
-    id: string;
-    name: string;
-    description: string;
-    is_critical: boolean;
-    created_at?: string;
-    updated_at?: string;
-    [key: string]: any;
-}
-/**
- * Get test cases for a feature
- */
-export declare function getTestCases(mcpServerUrl: string, mcpToken: string, featureId: string, verbose?: boolean): Promise<TestCase[]>;
-/**
- * Create a new test case for a feature
- */
-export declare function createTestCase(mcpServerUrl: string, mcpToken: string, featureId: string, testCase: {
-    name: string;
-    description: string;
-    is_critical?: boolean;
-}, verbose?: boolean): Promise<boolean>;
-/**
- * Create multiple test cases for a feature
- */
-export declare function createTestCases(mcpServerUrl: string, mcpToken: string, featureId: string, testCases: Array<{
-    name: string;
-    description: string;
-    is_critical?: boolean;
-}>, verbose?: boolean): Promise<boolean>;
-/**
- * Filter features by status
- */
-export declare function filterFeaturesByStatus(features: FeatureInfo[], status: string): FeatureInfo[];
-/**
- * Sort features by updated_at (most recent first)
- */
-export declare function sortFeaturesByUpdatedAt(features: FeatureInfo[]): FeatureInfo[];
-/**
- * Get features with ready_for_dev status for a product
- */
-export declare function getReadyForDevFeatures(mcpServerUrl: string, mcpToken: string, productId: string, verbose?: boolean): Promise<FeatureInfo[]>;