edsger 0.77.0 → 0.79.0

package/dist/services/feedbacks.js

@@ -1,264 +0,0 @@
-/**
- * Feedbacks service for pipeline integration
- * Provides human-guided feedbacks to influence Claude Code behavior in each phase
- */
-import { getMcpServerUrl, getMcpToken } from '../auth/auth-store.js';
-import { downloadImagesForClaudeCode } from '../utils/image-downloader.js';
-import { logDebug, logError, logInfo, logSuccess, logWarning, } from '../utils/logger.js';
-/**
- * Fetch feedbacks for a specific phase
- * Includes both issue-level and product-level feedbacks
- * For multi-branch issues, can optionally filter by branch_id
- */
-export async function getFeedbacksForPhase(options, phase, branchId) {
-    const { issueId, verbose } = options;
-    const mcpServerUrl = getMcpServerUrl();
-    const mcpToken = getMcpToken();
-    // Convert phase name from hyphen to underscore format for database compatibility
-    // e.g., 'issue-analysis' -> 'issue_analysis'
-    const dbPhase = phase.replace(/-/g, '_');
-    const requestBody = {
-        jsonrpc: '2.0',
-        id: 1,
-        method: 'feedbacks/get',
-        params: {
-            issue_id: issueId,
-            phase: dbPhase,
-            ...(branchId ? { branch_id: branchId } : {}),
-        },
-    };
-    if (verbose) {
-        logInfo(`Fetching feedbacks: phase="${phase}" (db: "${dbPhase}"), issue_id="${issueId}"`);
-        logDebug(`Request body: ${JSON.stringify(requestBody, null, 2)}`, verbose);
-    }
-    const response = await fetch(`${mcpServerUrl}/mcp`, {
-        method: 'POST',
-        headers: {
-            'Content-Type': 'application/json',
-            Authorization: `Bearer ${mcpToken}`,
-        },
-        body: JSON.stringify(requestBody),
-    });
-    if (verbose) {
-        logDebug(`Response status: ${response.status} ${response.statusText}`, verbose);
-    }
-    if (!response.ok) {
-        const errorText = await response.text();
-        if (verbose) {
-            logError(`Response error body: ${errorText}`);
-        }
-        throw new Error(`Failed to fetch feedbacks for phase "${phase}": ${response.status} ${response.statusText}. Response: ${errorText}`);
-    }
-    const data = await response.json();
-    if (verbose) {
-        logDebug(`MCP response: ${JSON.stringify(data, null, 2)}`, verbose);
-    }
-    if (data.error) {
-        if (verbose) {
-            logError(`MCP error: ${JSON.stringify(data.error)}`);
-        }
-        throw new Error(`MCP Error for phase "${phase}": ${data.error.message || JSON.stringify(data.error)}`);
-    }
-    // Handle empty result gracefully
-    if (!data.result) {
-        if (verbose) {
-            logWarning(`Empty result from MCP, returning empty feedbacks array`);
-        }
-        return {
-            phase,
-            issue_id: issueId,
-            feedbacks: [],
-        };
-    }
-    if (verbose) {
-        logSuccess(`Successfully fetched ${data.result.feedbacks?.length || 0} feedbacks`);
-    }
-    return data.result;
-}
-/**
- * Format feedbacks context as string for LLM consumption
- * Downloads images from feedback content for Claude Code to view
- */
-export async function formatFeedbacksForContext(context) {
-    if (!context.feedbacks || context.feedbacks.length === 0) {
-        return '';
-    }
-    // Process images in all feedback contents
-    const processedFeedbacks = await Promise.all(context.feedbacks.map(async (feedback) => {
-        if (!feedback.content) {
-            return feedback;
-        }
-        const { processedMarkdown } = await downloadImagesForClaudeCode(feedback.content, context.issue_id);
-        return { ...feedback, content: processedMarkdown };
-    }));
-    // Group feedbacks by type
-    const grouped = groupBy(processedFeedbacks, 'feedback_type');
-    const sections = [];
-    // Requirements
-    if (grouped.requirement && grouped.requirement.length > 0) {
-        sections.push(`## 📋 Additional Requirements\n\n${formatFeedbacksList(grouped.requirement)}`);
-    }
-    // Constraints
-    if (grouped.constraint && grouped.constraint.length > 0) {
-        sections.push(`## 🚫 Constraints\n\n${formatFeedbacksList(grouped.constraint)}`);
-    }
-    // Preferences
-    if (grouped.preference && grouped.preference.length > 0) {
-        sections.push(`## 💡 Preferences\n\n${formatFeedbacksList(grouped.preference)}`);
-    }
-    // Context
-    if (grouped.context && grouped.context.length > 0) {
-        sections.push(`## 🔍 Additional Context\n\n${formatFeedbacksList(grouped.context)}`);
-    }
-    // Quality Criteria
-    if (grouped.quality_criteria && grouped.quality_criteria.length > 0) {
-        sections.push(`## ✅ Quality Criteria\n\n${formatFeedbacksList(grouped.quality_criteria)}`);
-    }
-    // Issues
-    if (grouped.issue && grouped.issue.length > 0) {
-        sections.push(`## 🐛 Issues to Address\n\n${formatFeedbacksList(grouped.issue)}`);
-    }
-    // Suggestions
-    if (grouped.suggestion && grouped.suggestion.length > 0) {
-        sections.push(`## 💭 Suggestions\n\n${formatFeedbacksList(grouped.suggestion)}`);
-    }
-    const phaseDisplay = context.phase.replace(/_/g, '-');
-    return `
----
-
-# 🎯 Human Feedbacks for ${phaseDisplay} Phase
-
-These feedbacks have been provided by the development team to guide your work in this phase. They represent domain knowledge, business constraints, and quality expectations that must be incorporated into your analysis and outputs.
-
-${sections.join('\n\n')}
-
----
-
-**IMPORTANT**: These human-provided feedbacks are MANDATORY and take precedence over default behavior. Please ensure your work:
-- ✅ Satisfies ALL requirements listed above
-- ✅ Respects ALL constraints
-- ✅ Incorporates stated preferences where possible
-- ✅ Considers the additional context provided
-- ✅ Meets ALL quality criteria
-
-If any feedback conflicts with checklist items or other requirements, prioritize the human feedbacks and note any conflicts in your response.
-`;
-}
-/**
- * Format a list of feedbacks with priority ordering
- */
-function formatFeedbacksList(feedbacks) {
-    // Sort by priority (highest first)
-    const sorted = [...feedbacks].sort((a, b) => b.priority - a.priority);
-    return sorted
-        .map((feedback, idx) => {
-        const priorityBadge = getPriorityBadge(feedback.priority);
-        // Build context metadata section
-        let contextInfo = '';
-        // Item references (User Story or Test Case)
-        if (feedback.user_story_id) {
-            contextInfo += `\n**User Story ID**: ${feedback.user_story_id}`;
-            contextInfo += `\n*Note: This feedback applies to the user story referenced above in the context. Look for the ID in the "Existing User Stories" section.*`;
-        }
-        if (feedback.test_case_id) {
-            contextInfo += `\n**Test Case ID**: ${feedback.test_case_id}`;
-            contextInfo += `\n*Note: This feedback applies to the test case referenced above in the context. Look for the ID in the "Existing Test Cases" section.*`;
-        }
-        // Document type
-        if (feedback.document_type) {
-            const docTypeDisplay = feedback.document_type
-                .split('_')
-                .map((word) => word.charAt(0).toUpperCase() + word.slice(1))
-                .join(' ');
-            contextInfo += `\n**Document**: ${docTypeDisplay}`;
-        }
-        // Target type
-        if (feedback.target_type && feedback.target_type !== 'phase') {
-            contextInfo += `\n**Target Type**: ${feedback.target_type}`;
-        }
-        // Build line reference info if available
-        if (feedback.line_number) {
-            contextInfo += `\n**Line**: ${feedback.line_number}`;
-        }
-        else if (feedback.line_range_start && feedback.line_range_end) {
-            contextInfo += `\n**Lines**: ${feedback.line_range_start}-${feedback.line_range_end}`;
-        }
-        // Context snippet
-        if (feedback.context_snippet) {
-            contextInfo += `\n**Referenced Content**:\n\`\`\`\n${feedback.context_snippet}\n\`\`\``;
-        }
-        return `### ${idx + 1}. ${feedback.title} ${priorityBadge}\n\n${feedback.content}${contextInfo}\n`;
-    })
-        .join('\n');
-}
-/**
- * Get priority badge emoji
- */
-function getPriorityBadge(priority) {
-    if (priority >= 9) {
-        return '🔴';
-    } // Critical
-    if (priority >= 7) {
-        return '🟠';
-    } // High
-    if (priority >= 5) {
-        return '🟡';
-    } // Medium
-    if (priority >= 3) {
-        return '🟢';
-    } // Low
-    return '⚪'; // Minimal
-}
-/**
- * Mark feedbacks as resolved
- * Used after successful verification to track which feedbacks have been addressed
- */
-export async function resolveFeedbacks(options, feedbackIds, verbose) {
-    const mcpServerUrl = getMcpServerUrl();
-    const mcpToken = getMcpToken();
-    if (!feedbackIds || feedbackIds.length === 0) {
-        return;
-    }
-    if (verbose) {
-        logInfo(`Marking ${feedbackIds.length} feedbacks as resolved: ${feedbackIds.join(', ')}`);
-    }
-    const response = await fetch(`${mcpServerUrl}/mcp`, {
-        method: 'POST',
-        headers: {
-            'Content-Type': 'application/json',
-            Authorization: `Bearer ${mcpToken}`,
-        },
-        body: JSON.stringify({
-            jsonrpc: '2.0',
-            id: 1,
-            method: 'feedbacks/resolve',
-            params: {
-                feedback_ids: feedbackIds,
-            },
-        }),
-    });
-    if (!response.ok) {
-        const errorText = await response.text();
-        throw new Error(`Failed to resolve feedbacks: ${response.status} ${response.statusText}. Response: ${errorText}`);
-    }
-    const data = await response.json();
-    if (data.error) {
-        throw new Error(`MCP Error resolving feedbacks: ${data.error.message || JSON.stringify(data.error)}`);
-    }
-    if (verbose) {
-        logSuccess(`Successfully marked ${data.result?.count || 0} feedbacks as resolved`);
-    }
-}
-/**
- * Group array of objects by a key
- */
-function groupBy(array, key) {
-    return array.reduce((result, item) => {
-        const groupKey = String(item[key]);
-        if (!result[groupKey]) {
-            result[groupKey] = [];
-        }
-        result[groupKey].push(item);
-        return result;
-    }, {});
-}

package/dist/services/phase-hooks/bindings-fetcher.d.ts

@@ -1,21 +0,0 @@
-/**
- * Bindings fetcher — retrieves phase hook bindings from Supabase via MCP
- * and manages a per-issue in-memory cache so bindings are fetched once
- * per workflow execution, not once per phase.
- */
-import type { HookPoint, PhaseHookBinding, ResolvedHookBindings } from './types.js';
-export declare function cacheBindings(issueId: string, productId: string, bindings: readonly PhaseHookBinding[]): void;
-export declare function getCachedBindings(issueId: string): ResolvedHookBindings | null;
-export declare function clearBindingsCache(issueId: string): void;
-/**
- * Fetch all enabled hook bindings for a product from Supabase via MCP.
- */
-export declare function fetchHookBindings(productId: string, verbose?: boolean): Promise<PhaseHookBinding[]>;
-/**
- * Filter bindings for a specific phase + hook point.
- *
- * A binding matches if its `phase` equals the given phase name
- * OR if it is the wildcard `'*'` (applies to all phases).
- * Results are sorted by `sort_order` ascending.
- */
-export declare function getBindingsForPhase(bindings: readonly PhaseHookBinding[], phase: string, hookPoint: HookPoint): readonly PhaseHookBinding[];

package/dist/services/phase-hooks/bindings-fetcher.js

@@ -1,53 +0,0 @@
-/**
- * Bindings fetcher — retrieves phase hook bindings from Supabase via MCP
- * and manages a per-issue in-memory cache so bindings are fetched once
- * per workflow execution, not once per phase.
- */
-import { callMcpEndpoint } from '../../api/mcp-client.js';
-import { logDebug } from '../../utils/logger.js';
-// ---- Per-issue cache ----
-const bindingsCache = new Map();
-export function cacheBindings(issueId, productId, bindings) {
-    bindingsCache.set(issueId, {
-        productId,
-        bindings,
-        fetchedAt: Date.now(),
-    });
-}
-export function getCachedBindings(issueId) {
-    return bindingsCache.get(issueId) ?? null;
-}
-export function clearBindingsCache(issueId) {
-    bindingsCache.delete(issueId);
-}
-// ---- Fetching ----
-/**
- * Fetch all enabled hook bindings for a product from Supabase via MCP.
- */
-export async function fetchHookBindings(productId, verbose) {
-    logDebug(`Fetching phase hook bindings for product ${productId}`, verbose);
-    const result = await callMcpEndpoint('product_phase_hooks/list', {
-        product_id: productId,
-        enabled: true,
-    });
-    const bindings = Array.isArray(result) ? result : [];
-    if (verbose && bindings.length > 0) {
-        logDebug(`Found ${String(bindings.length)} hook bindings for product ${productId}`, verbose);
-    }
-    return bindings;
-}
-// ---- Filtering (pure) ----
-/**
- * Filter bindings for a specific phase + hook point.
- *
- * A binding matches if its `phase` equals the given phase name
- * OR if it is the wildcard `'*'` (applies to all phases).
- * Results are sorted by `sort_order` ascending.
- */
-export function getBindingsForPhase(bindings, phase, hookPoint) {
-    return bindings
-        .filter((b) => b.enabled &&
-        b.hook_point === hookPoint &&
-        (b.phase === phase || b.phase === '*'))
-        .sort((a, b) => a.sort_order - b.sort_order);
-}

package/dist/services/phase-hooks/hook-executor.d.ts

@@ -1,36 +0,0 @@
-/**
- * Hook executor — executes a single phase hook by reading a Claude Code
- * plugin SKILL.md file and invoking `query()` from the Agent SDK.
- */
-import { query } from '@anthropic-ai/claude-agent-sdk';
-import type { HookContext, HookExecutionResult, ParsedSkillFile, PhaseHookBinding } from './types.js';
-export interface HookExecutorDeps {
-    loadSkillFile: (pluginName: string, skillName: string, verbose?: boolean) => Promise<ParsedSkillFile | null>;
-    queryFn: typeof query;
-}
-/**
- * Build the user-facing prompt sent to `query()` for a hook invocation.
- * The skill body goes into the system prompt; this function builds the
- * *user* prompt with phase-specific context.
- */
-export declare function buildHookPrompt(binding: PhaseHookBinding, context: HookContext): string;
-/**
- * Execute a single hook binding.
- *
- * 1. Loads the SKILL.md file from the Claude Code plugin cache
- * 2. Builds a prompt with phase context
- * 3. Calls `query()` from claude-agent-sdk
- * 4. Returns the execution result
- */
-export declare function executeHook(binding: PhaseHookBinding, context: HookContext, verbose?: boolean, deps?: HookExecutorDeps): Promise<HookExecutionResult>;
-interface HookResponse {
-    status: 'success' | 'error';
-    message: string;
-    data?: unknown;
-}
-/**
- * Parse the hook response text, looking for a JSON block.
- * Falls back to treating the entire text as a success message.
- */
-export declare function parseHookResponse(text: string): HookResponse;
-export {};

package/dist/services/phase-hooks/hook-executor.js

@@ -1,167 +0,0 @@
-/**
- * Hook executor — executes a single phase hook by reading a Claude Code
- * plugin SKILL.md file and invoking `query()` from the Agent SDK.
- */
-import { query } from '@anthropic-ai/claude-agent-sdk';
-import { DEFAULT_MODEL } from '../../constants.js';
-import { logDebug } from '../../utils/logger.js';
-import { loadSkillFile } from './plugin-loader.js';
-const defaultDeps = {
-    loadSkillFile,
-    queryFn: query,
-};
-// ---- Prompt building (pure) ----
-/**
- * Build the user-facing prompt sent to `query()` for a hook invocation.
- * The skill body goes into the system prompt; this function builds the
- * *user* prompt with phase-specific context.
- */
-export function buildHookPrompt(binding, context) {
-    const sections = [
-        '## Phase Hook Execution Context',
-        '',
-        `- **Issue ID**: ${context.issueId}`,
-        `- **Phase**: ${context.phase}`,
-        `- **Hook Point**: ${context.hookPoint}`,
-        `- **Plugin**: ${binding.plugin_name}`,
-        `- **Skill**: ${binding.skill_name}`,
-    ];
-    // Inject binding-level config if provided
-    if (Object.keys(binding.config).length > 0) {
-        sections.push('', '## Hook Configuration', '');
-        sections.push('```json', JSON.stringify(binding.config, null, 2), '```');
-    }
-    // For 'after' hooks, include the phase result
-    if (context.hookPoint === 'after' && context.phaseResult !== undefined) {
-        sections.push('', '## Phase Result', '');
-        sections.push('```json', JSON.stringify(context.phaseResult, null, 2), '```');
-    }
-    // For 'on_error' hooks, include the error
-    if (context.hookPoint === 'on_error' && context.error) {
-        sections.push('', '## Phase Error', '');
-        sections.push(`**Error**: ${context.error.message}`);
-        if (context.error.stack) {
-            sections.push('', '```', context.error.stack, '```');
-        }
-    }
-    sections.push('', '## Instructions', '', 'Execute the skill described in your system prompt using the context above.', 'Return a JSON block with your result:', '', '```json', '{ "status": "success" | "error", "message": "...", "data": {} }', '```');
-    return sections.join('\n');
-}
-// ---- Execution ----
-/**
- * Execute a single hook binding.
- *
- * 1. Loads the SKILL.md file from the Claude Code plugin cache
- * 2. Builds a prompt with phase context
- * 3. Calls `query()` from claude-agent-sdk
- * 4. Returns the execution result
- */
-export async function executeHook(binding, context, verbose, deps = defaultDeps) {
-    const startTime = Date.now();
-    // 1. Load skill file
-    const skillFile = await deps.loadSkillFile(binding.plugin_name, binding.skill_name, verbose);
-    if (!skillFile) {
-        return {
-            hookId: binding.id,
-            binding,
-            status: 'skipped',
-            message: `Skill file not found: ${binding.plugin_name}/${binding.skill_name}`,
-            duration_ms: Date.now() - startTime,
-        };
-    }
-    // 2. Build prompt
-    const hookPrompt = buildHookPrompt(binding, context);
-    if (verbose) {
-        logDebug(`Executing hook: ${binding.plugin_name}/${binding.skill_name} ` +
-            `(${context.hookPoint}:${context.phase})`, verbose);
-    }
-    // 3. Call query()
-    try {
-        let resultText = '';
-        for await (const message of deps.queryFn({
-            prompt: hookPrompt,
-            options: {
-                systemPrompt: {
-                    type: 'preset',
-                    preset: 'claude_code',
-                    append: skillFile.body,
-                },
-                model: skillFile.frontmatter.model || DEFAULT_MODEL,
-                maxTurns: skillFile.frontmatter.maxTurns ?? 50,
-                permissionMode: 'bypassPermissions',
-            },
-        })) {
-            if (message.type === 'assistant') {
-                // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                for (const item of (message.message?.content ?? [])) {
-                    // eslint-disable-next-line max-depth
-                    if (item.type === 'text') {
-                        resultText += item.text;
-                    }
-                }
-                continue;
-            }
-            if (message.type === 'result') {
-                if (message.subtype === 'success' && message.result) {
-                    resultText = message.result;
-                }
-            }
-        }
-        // 4. Parse result
-        const parsed = parseHookResponse(resultText);
-        return {
-            hookId: binding.id,
-            binding,
-            status: parsed.status === 'error' ? 'error' : 'success',
-            message: parsed.message,
-            duration_ms: Date.now() - startTime,
-            data: parsed.data,
-        };
-    }
-    catch (error) {
-        return {
-            hookId: binding.id,
-            binding,
-            status: 'error',
-            message: `Hook execution failed: ${error instanceof Error ? error.message : String(error)}`,
-            duration_ms: Date.now() - startTime,
-        };
-    }
-}
-/**
- * Parse the hook response text, looking for a JSON block.
- * Falls back to treating the entire text as a success message.
- */
-export function parseHookResponse(text) {
-    // Try to extract JSON from a fenced code block
-    const jsonMatch = text.match(/```json\s*\n([\s\S]*?)\n\s*```/);
-    if (jsonMatch) {
-        try {
-            const parsed = JSON.parse(jsonMatch[1]);
-            return {
-                status: parsed.status === 'error' ? 'error' : 'success',
-                message: parsed.message || 'Hook completed',
-                data: parsed.data,
-            };
-        }
-        catch {
-            // Fall through to plain text handling
-        }
-    }
-    // Try parsing the entire text as JSON
-    try {
-        const parsed = JSON.parse(text);
-        return {
-            status: parsed.status === 'error' ? 'error' : 'success',
-            message: parsed.message || 'Hook completed',
-            data: parsed.data,
-        };
-    }
-    catch {
-        // Not JSON — treat as success with the text as the message
-        return {
-            status: 'success',
-            message: text.trim().slice(0, 500) || 'Hook completed (no structured output)',
-        };
-    }
-}

package/dist/services/phase-hooks/hook-logging.d.ts

@@ -1,14 +0,0 @@
-/**
- * Hook-specific audit logging — wraps the generic audit log service
- * with hook-specific metadata fields.
- */
-import type { HookExecutionResult, PhaseHookBinding } from './types.js';
-export interface LogHookEventParams {
-    issueId: string;
-    binding: PhaseHookBinding;
-    result: HookExecutionResult;
-}
-/**
- * Log a hook execution event to the issue audit log.
- */
-export declare function logHookEvent(params: LogHookEventParams, verbose?: boolean): Promise<void>;

package/dist/services/phase-hooks/hook-logging.js

@@ -1,41 +0,0 @@
-/**
- * Hook-specific audit logging — wraps the generic audit log service
- * with hook-specific metadata fields.
- */
-import { callMcpEndpoint } from '../../api/mcp-client.js';
-import { logDebug, logError } from '../../utils/logger.js';
-const EVENT_TYPE_MAP = {
-    success: 'hook_completed',
-    error: 'hook_failed',
-    skipped: 'hook_completed', // skipped is a non-error completion
-};
-/**
- * Log a hook execution event to the issue audit log.
- */
-export async function logHookEvent(params, verbose) {
-    const { issueId, binding, result } = params;
-    const eventType = EVENT_TYPE_MAP[result.status];
-    try {
-        await callMcpEndpoint('issue_audit_logs/create', {
-            issue_id: issueId,
-            event_type: eventType,
-            phase: binding.phase === '*' ? 'all' : binding.phase.replace(/-/g, '_'),
-            source: 'pipeline',
-            result: result.status === 'error' ? 'error' : 'success',
-            metadata: {
-                hook_id: binding.id,
-                plugin_name: binding.plugin_name,
-                skill_name: binding.skill_name,
-                hook_point: binding.hook_point,
-                on_failure: binding.on_failure,
-                duration_ms: result.duration_ms,
-                hook_status: result.status,
-                hook_message: result.message,
-            },
-        });
-        logDebug(`Logged hook event: ${eventType} for ${binding.plugin_name}/${binding.skill_name}`, verbose);
-    }
-    catch (error) {
-        logError(`Failed to log hook event: ${error instanceof Error ? error.message : String(error)}`);
-    }
-}

package/dist/services/phase-hooks/hook-runner.d.ts

@@ -1,19 +0,0 @@
-/**
- * Hook runner — orchestrates all hooks for a given phase + hook point.
- *
- * Executes matching bindings sequentially (respecting sort_order),
- * applies the on_failure policy, and logs each result.
- */
-import type { HookContext, HookExecutionResult, HookRunnerDeps } from './types.js';
-export interface HookRunResult {
-    readonly results: readonly HookExecutionResult[];
-    readonly blocked: boolean;
-}
-/**
- * Run all matching hooks for a phase at a given hook point.
- *
- * @param context - Phase context (issueId, phase, hookPoint, etc.)
- * @param deps    - Injectable dependencies (defaults to real implementations).
- *                  Pass mock deps in tests to avoid SDK/network calls.
- */
-export declare function runHooksForPhase(context: HookContext, deps?: HookRunnerDeps): Promise<HookRunResult>;