edsger 0.76.0 → 0.78.0

package/dist/phases/pr-splitting/prompts.js

@@ -1,154 +0,0 @@
-import { getDefaultBranchForIssue } from '../../services/repo-config.js';
-import { resolveSkill, substituteVariables, } from '../../services/skill-resolver.js';
-import { OUTPUT_CONTRACTS } from '../output-contracts.js';
-/**
- * Create the system prompt for PR splitting: Diff analysis and PR planning
- */
-export async function createPRSplittingSystemPrompt(config, issueId, projectDir, verbose) {
-    const skill = await resolveSkill('phase/pr-splitting', {
-        projectDir,
-    });
-    if (!skill) {
-        throw new Error('Failed to load skill: phase/pr-splitting');
-    }
-    let { prompt } = skill;
-    prompt = substituteVariables(prompt, {
-        BASE_BRANCH: await getDefaultBranchForIssue(issueId, verbose),
-        ISSUE_ID: issueId,
-    });
-    return `${prompt}\n\n${OUTPUT_CONTRACTS['pr-splitting']}`;
-}
-/**
- * Create the user prompt with diff context for PR splitting
- */
-export function createPRSplittingPromptWithContext(issueId, contextInfo, existingPRsInfo, diffStat, changedFiles) {
-    let prompt = `# PR Splitting Task
-
-Please analyze the actual code changes on the \`dev/${issueId}\` branch and create a plan to split them into multiple smaller PRs for review.
-
-## Issue Context
-
-${contextInfo}
-
-## Code Changes Summary
-
-### Diff Stat
-\`\`\`
-${diffStat || 'No changes detected'}
-\`\`\`
-
-### Changed Files (${changedFiles.length} files)
-${changedFiles.map((f) => `- ${f}`).join('\n') || 'No files changed'}
-
-`;
-    if (existingPRsInfo) {
-        prompt += `## Existing Pull Requests
-
-${existingPRsInfo}
-
-**Note**: Merged/closed PRs are frozen — do not modify them or reassign their files.
-
-`;
-    }
-    prompt += `## Your Task
-
-1. **Examine the actual diff**: Run \`git diff main...dev/${issueId}\` or targeted diffs for specific files to understand what changed
-2. **Identify logical groupings**: Find files that change together for the same reason, considering module boundaries
-3. **Determine dependencies**: Figure out which groups must be merged first
-4. **Create PR plan**: Define PRs with clear scope, file assignments, and acceptance criteria
-
-**Remember**:
-- Every changed file must be assigned to exactly one PR
-- Smaller, focused PRs are better than large ones
-- Split by module/domain, not just by layer
-- Order PRs by their dependencies`;
-    return prompt;
-}
-/**
- * Format the context information for the prompt
- */
-export function formatContextForPrompt(issue, product, branches) {
-    let context = `### Issue: ${issue.name}
-
-${issue.description || 'No description provided'}
-
-### Product: ${product.name}
-
-${product.description || 'No description provided'}
-
-`;
-    if (issue.technical_design) {
-        context += `### Technical Design
-
-${issue.technical_design}
-
-`;
-    }
-    if (branches.length > 0) {
-        context += `### Development Branches (${branches.length})
-
-${branches.map((b, idx) => `${idx + 1}. **${b.name}** (${b.status}) — ${b.branch_name || 'No branch'}`).join('\n')}
-
-`;
-    }
-    return context;
-}
-/**
- * Format existing pull requests for the prompt
- */
-export function formatExistingPRsForPrompt(pullRequests) {
-    if (!pullRequests || pullRequests.length === 0) {
-        return '';
-    }
-    const frozen = pullRequests.filter((pr) => pr.status === 'merged' || pr.status === 'closed');
-    const mutable = pullRequests.filter((pr) => pr.status !== 'merged' && pr.status !== 'closed');
-    const formatPR = (pr) => {
-        const filesInfo = pr.files && pr.files.length > 0
-            ? `\n   - Files: ${pr.files.map((f) => f.path).join(', ')}`
-            : '';
-        return `${pr.sequence}. **${pr.name}** (${pr.status})
-   - Branch: ${pr.branch_name || 'Not created'}
-   - Description: ${pr.description || 'No description'}${filesInfo}`;
-    };
-    let result = '';
-    if (frozen.length > 0) {
-        result += `### Frozen PRs (merged/closed — DO NOT modify)\n\n${frozen
-            .sort((a, b) => a.sequence - b.sequence)
-            .map(formatPR)
-            .join('\n\n')}\n\n`;
-    }
-    if (mutable.length > 0) {
-        result += `### Active PRs (can be updated)\n\n${mutable
-            .sort((a, b) => a.sequence - b.sequence)
-            .map(formatPR)
-            .join('\n\n')}`;
-    }
-    return result;
-}
-/**
- * Create improvement prompt for re-planning based on feedback
- */
-export function createImprovementPrompt(feedback, currentPlan) {
-    return `# PR Splitting Improvement
-
-The current PR splitting plan needs improvement based on the following feedback:
-
-## Feedback
-
-${feedback}
-
-## Current Plan
-
-${currentPlan}
-
-## Your Task
-
-Please revise the PR splitting plan to address the feedback. Ensure the new plan:
-1. Addresses all feedback points
-2. Maintains proper dependency ordering
-3. Keeps PRs reasonably sized for code review
-4. Assigns every changed file to exactly one PR
-5. Provides clear scope and acceptance criteria for each PR
-
-Respond with the updated JSON PR splitting plan.`;
-}

package/dist/phases/product-techniques/index.d.ts

@@ -1,52 +0,0 @@
-/**
- * product-techniques phase: clone the product's repo, ask Claude (via the
- * `submit_techniques` MCP tool) to write a catalogue of the techniques the
- * repo uses, and persist the result to product_techniques via the Supabase
- * SDK.
- *
- * Mirrors the screen-flow pattern. Production-grade behaviours layered on
- * top of the basic generate-and-write loop:
- *
- *   - Heartbeat: `last_heartbeat_at` is refreshed on every assistant message
- *     so the reader can detect stalled / crashed runs (see services/db/
- *     product-techniques.ts for the lazy reaper).
- *   - Cancellation-safe writes: markRunning / markSuccess / markFailed only
- *     touch rows whose status is in {pending, running}. If the user clicked
- *     Stop and the row is now 'cancelled', the final write no-ops.
- *   - Tool-based submission: validated server-side via Zod + content checks
- *     (mcp-server.ts). Falls back to fenced JSON parsing for resilience.
- */
-import type { SupabaseClient } from '@supabase/supabase-js';
-export interface ProductTechniquesOptions {
-    productId: string;
-    techniquesId: string;
-    guidance?: string;
-    verbose?: boolean;
-}
-export interface ProductTechniquesResult {
-    status: 'success' | 'error' | 'cancelled';
-    message: string;
-    summary?: string;
-}
-export declare function runProductTechniquesPhase(options: ProductTechniquesOptions): Promise<ProductTechniquesResult>;
-/**
- * Claim the row by flipping `pending` → `running`. Returns true on success
- * (we won the claim) and false when the row has already moved on (e.g. user
- * cancelled before the CLI started). Bounded by the status filter so we
- * can't accidentally resurrect a 'cancelled' row.
- */
-export declare function markRunning(supabase: SupabaseClient, techniquesId: string): Promise<boolean>;
-/**
- * Touch the heartbeat. Best-effort — if it fails (network blip, RLS), the
- * agent loop keeps running; the reader treats this row as stale and marks
- * it failed on next read, which is the correct behaviour.
- */
-export declare function heartbeat(supabase: SupabaseClient, techniquesId: string): Promise<void>;
-/**
- * Write failure status iff the row is still in an active state. Returns
- * true if the row was actually updated (so the caller knows whether the
- * agent's verdict made it to the DB). Returns false when the row has
- * already been cancelled or otherwise resolved by someone else.
- */
-export declare function markFailed(supabase: SupabaseClient, techniquesId: string, errorMessage: string): Promise<boolean>;
-export declare function markSuccess(supabase: SupabaseClient, techniquesId: string, summary: string, content: string): Promise<boolean>;

package/dist/phases/product-techniques/index.js

@@ -1,268 +0,0 @@
-/**
- * product-techniques phase: clone the product's repo, ask Claude (via the
- * `submit_techniques` MCP tool) to write a catalogue of the techniques the
- * repo uses, and persist the result to product_techniques via the Supabase
- * SDK.
- *
- * Mirrors the screen-flow pattern. Production-grade behaviours layered on
- * top of the basic generate-and-write loop:
- *
- *   - Heartbeat: `last_heartbeat_at` is refreshed on every assistant message
- *     so the reader can detect stalled / crashed runs (see services/db/
- *     product-techniques.ts for the lazy reaper).
- *   - Cancellation-safe writes: markRunning / markSuccess / markFailed only
- *     touch rows whose status is in {pending, running}. If the user clicked
- *     Stop and the row is now 'cancelled', the final write no-ops.
- *   - Tool-based submission: validated server-side via Zod + content checks
- *     (mcp-server.ts). Falls back to fenced JSON parsing for resilience.
- */
-import { query } from '@anthropic-ai/claude-agent-sdk';
-import { getGitHubConfigByProduct } from '../../api/github.js';
-import { DEFAULT_MODEL } from '../../constants.js';
-import { getSupabase } from '../../supabase/client.js';
-import { logError, logInfo, logSuccess, logWarning, } from '../../utils/logger.js';
-import { cleanupIssueRepo, cloneIssueRepo, ensureWorkspaceDir, } from '../../workspace/workspace-manager.js';
-import { fetchProductBasics } from '../find-shared/mcp.js';
-import { createPromptGenerator, extractTextFromContent, tryExtractResult, } from '../pr-shared/agent-utils.js';
-import { createTechniquesCaptureState, createTechniquesMcpServer, validateContent, } from './mcp-server.js';
-import { createProductTechniquesSystemPrompt, createProductTechniquesUserPrompt, } from './prompts.js';
-import { isTechniquesExtraction, TECHNIQUES_CONTENT_MAX, TECHNIQUES_SUMMARY_MAX, } from './types.js';
-const WORKSPACE_KEY = 'product-techniques';
-const MAX_TURNS = 120;
-// Heartbeat cadence: at most one DB write per HEARTBEAT_MIN_INTERVAL_MS.
-// Triggered on every assistant message so a stalled agent (no messages
-// flowing) lets the row go stale and the reader can mark it failed.
-const HEARTBEAT_MIN_INTERVAL_MS = 15_000;
-export async function runProductTechniquesPhase(options) {
-    const { productId, techniquesId, guidance, verbose } = options;
-    logInfo(`Starting product-techniques generation for product ${productId}`);
-    const supabase = getSupabase();
-    const claimed = await markRunning(supabase, techniquesId);
-    if (!claimed) {
-        return {
-            status: 'cancelled',
-            message: 'Techniques row is no longer in a runnable state (likely cancelled before the CLI started)',
-        };
-    }
-    const githubConfig = await getGitHubConfigByProduct(productId, verbose);
-    if (!githubConfig.configured ||
-        !githubConfig.token ||
-        !githubConfig.owner ||
-        !githubConfig.repo) {
-        const msg = githubConfig.message ||
-            'GitHub repository not configured for this product. Connect a repo first.';
-        await markFailed(supabase, techniquesId, msg);
-        return { status: 'error', message: msg };
-    }
-    let repoPath;
-    let succeeded = false;
-    try {
-        const workspaceRoot = ensureWorkspaceDir();
-        const repoKey = `${WORKSPACE_KEY}-${productId}`;
-        ({ repoPath } = cloneIssueRepo(workspaceRoot, repoKey, githubConfig.owner, githubConfig.repo, githubConfig.token));
-        const product = await fetchProductBasics(productId);
-        const systemPrompt = createProductTechniquesSystemPrompt();
-        const userPrompt = createProductTechniquesUserPrompt({
-            productName: product.name,
-            productDescription: product.description,
-            guidance,
-        });
-        logInfo('Running Claude agent to write techniques catalogue...');
-        const captureState = createTechniquesCaptureState();
-        const mcpServer = createTechniquesMcpServer(captureState);
-        let lastAssistantResponse = '';
-        let lastHeartbeatAt = 0;
-        for await (const message of query({
-            prompt: createPromptGenerator(userPrompt),
-            options: {
-                systemPrompt: {
-                    type: 'preset',
-                    preset: 'claude_code',
-                    append: systemPrompt,
-                },
-                model: DEFAULT_MODEL,
-                maxTurns: MAX_TURNS,
-                permissionMode: 'bypassPermissions',
-                cwd: repoPath,
-                mcpServers: {
-                    'product-techniques': mcpServer,
-                },
-            },
-        })) {
-            if (message.type === 'assistant') {
-                lastAssistantResponse += extractTextFromContent(message.message?.content ?? [], verbose);
-                // Throttled heartbeat. Awaited (cheap UPDATE) so we don't pile up
-                // unresolved promises on a long run.
-                const now = Date.now();
-                if (now - lastHeartbeatAt >= HEARTBEAT_MIN_INTERVAL_MS) {
-                    lastHeartbeatAt = now;
-                    await heartbeat(supabase, techniquesId);
-                }
-                continue;
-            }
-            if (message.type !== 'result') {
-                continue;
-            }
-            // Prefer the MCP-captured extraction. Fall back to fenced JSON only
-            // if the agent ignored the tool — robustness, not a contract.
-            const fromTool = captureState.captured;
-            const fromFallback = fromTool
-                ? null
-                : tryFallbackParse(message, lastAssistantResponse);
-            const extraction = fromTool ?? fromFallback;
-            if (!extraction) {
-                const msg = message.subtype === 'success'
-                    ? 'Techniques generation failed: agent did not call submit_techniques and no parseable fallback was found'
-                    : `Techniques generation failed: agent ${message.subtype}`;
-                const written = await markFailed(supabase, techniquesId, msg);
-                return {
-                    status: written ? 'error' : 'cancelled',
-                    message: written
-                        ? msg
-                        : 'Generation was cancelled while the agent was running',
-                };
-            }
-            if (fromFallback) {
-                logWarning('Agent skipped submit_techniques; used fenced fallback JSON instead');
-            }
-            const written = await markSuccess(supabase, techniquesId, extraction.summary, extraction.content);
-            if (!written) {
-                return {
-                    status: 'cancelled',
-                    message: 'Generation was cancelled before the result could be written',
-                };
-            }
-            succeeded = true;
-            logSuccess(`Techniques catalogue generated (${extraction.content.length} chars of markdown)`);
-            return {
-                status: 'success',
-                message: 'Techniques catalogue generated',
-                summary: extraction.summary,
-            };
-        }
-        // Loop ended without a 'result' message — treat as failure.
-        const msg = 'Techniques generation ended without a result message';
-        await markFailed(supabase, techniquesId, msg);
-        return { status: 'error', message: msg };
-    }
-    catch (error) {
-        const errorMessage = error instanceof Error ? error.message : String(error);
-        logError(`Techniques generation failed: ${errorMessage}`);
-        await markFailed(supabase, techniquesId, errorMessage);
-        return { status: 'error', message: errorMessage };
-    }
-    finally {
-        if (succeeded) {
-            cleanupIssueRepo(repoPath);
-        }
-    }
-}
-// Fallback parser: extract a fenced `techniques` JSON block from the final
-// assistant text if the agent skipped the submit_techniques tool. Backstop
-// only — we expect the tool path to be the norm.
-function tryFallbackParse(resultMessage, assistantText) {
-    const responseText = resultMessage.subtype === 'success'
-        ? resultMessage.result || assistantText
-        : assistantText;
-    const parsed = tryExtractResult(responseText, 'techniques');
-    if (!isTechniquesExtraction(parsed)) {
-        return null;
-    }
-    if (parsed.summary.length > TECHNIQUES_SUMMARY_MAX) {
-        return null;
-    }
-    if (parsed.content.length > TECHNIQUES_CONTENT_MAX) {
-        return null;
-    }
-    const { error } = validateContent(parsed.content);
-    if (error) {
-        return null;
-    }
-    return parsed;
-}
-// ============================================================================
-// Persistence — exported for unit tests
-// ============================================================================
-/**
- * Claim the row by flipping `pending` → `running`. Returns true on success
- * (we won the claim) and false when the row has already moved on (e.g. user
- * cancelled before the CLI started). Bounded by the status filter so we
- * can't accidentally resurrect a 'cancelled' row.
- */
-export async function markRunning(supabase, techniquesId) {
-    const { data, error } = await supabase
-        .from('product_techniques')
-        .update({
-        status: 'running',
-        error: null,
-        last_heartbeat_at: new Date().toISOString(),
-    })
-        .eq('id', techniquesId)
-        .in('status', ['pending', 'running'])
-        .select('id')
-        .maybeSingle();
-    if (error) {
-        logWarning(`Could not mark techniques as running: ${error.message}`);
-        return false;
-    }
-    return data !== null;
-}
-/**
- * Touch the heartbeat. Best-effort — if it fails (network blip, RLS), the
- * agent loop keeps running; the reader treats this row as stale and marks
- * it failed on next read, which is the correct behaviour.
- */
-export async function heartbeat(supabase, techniquesId) {
-    const { error } = await supabase
-        .from('product_techniques')
-        .update({ last_heartbeat_at: new Date().toISOString() })
-        .eq('id', techniquesId)
-        .eq('status', 'running');
-    if (error) {
-        logWarning(`Heartbeat failed: ${error.message}`);
-    }
-}
-/**
- * Write failure status iff the row is still in an active state. Returns
- * true if the row was actually updated (so the caller knows whether the
- * agent's verdict made it to the DB). Returns false when the row has
- * already been cancelled or otherwise resolved by someone else.
- */
-export async function markFailed(supabase, techniquesId, errorMessage) {
-    const { data, error } = await supabase
-        .from('product_techniques')
-        .update({
-        status: 'failed',
-        error: errorMessage,
-        completed_at: new Date().toISOString(),
-    })
-        .eq('id', techniquesId)
-        .in('status', ['pending', 'running'])
-        .select('id')
-        .maybeSingle();
-    if (error) {
-        logWarning(`Could not mark techniques as failed: ${error.message}`);
-        return false;
-    }
-    return data !== null;
-}
-export async function markSuccess(supabase, techniquesId, summary, content) {
-    const { data, error } = await supabase
-        .from('product_techniques')
-        .update({
-        status: 'success',
-        summary,
-        content,
-        error: null,
-        completed_at: new Date().toISOString(),
-    })
-        .eq('id', techniquesId)
-        .in('status', ['pending', 'running'])
-        .select('id')
-        .maybeSingle();
-    if (error) {
-        logWarning(`Could not mark techniques as success: ${error.message}`);
-        return false;
-    }
-    return data !== null;
-}

package/dist/phases/product-techniques/mcp-server.d.ts

@@ -1,41 +0,0 @@
-/**
- * In-process MCP server exposing a single tool — `submit_techniques` — that
- * the Claude Agent SDK session calls to return the final markdown catalogue.
- *
- * Using a tool call instead of parsing a fenced JSON block lets the SDK
- * enforce the schema (via Zod) and lets the agent self-correct when
- * validation fails: the error message goes back as the tool result and the
- * agent can re-call the tool with corrected data.
- *
- * The capture pattern: callers pass in a `TechniquesCaptureState`. The tool
- * handler stores the validated args on `state.captured`. The orchestrator
- * reads it after the SDK loop ends.
- */
-import { z } from 'zod';
-import { type TechniquesExtraction } from './types.js';
-export interface TechniquesCaptureState {
-    captured: TechniquesExtraction | null;
-}
-export declare function createTechniquesCaptureState(): TechniquesCaptureState;
-/**
- * Validation that goes beyond the basic Zod schema: enforce that the
- * markdown actually has the H2 sections the prompt asks for. The agent gets
- * an actionable error and can re-submit.
- *
- * We don't require ALL six sections — agents on tiny repos often legitimately
- * collapse some. We require at least the first one ("Languages & Runtime")
- * plus "Notable Techniques", which the prompt calls out as the whole point.
- */
-export declare function validateContent(content: string): {
-    error: string | null;
-};
-/**
- * Build the `submit_techniques` tool. Exported separately from the server
- * so tests can exercise the handler directly without going through MCP
- * transport.
- */
-export declare function createSubmitTechniquesTool(state: TechniquesCaptureState): import("@anthropic-ai/claude-agent-sdk").SdkMcpToolDefinition<{
-    summary: z.ZodString;
-    content: z.ZodString;
-}>;
-export declare function createTechniquesMcpServer(state: TechniquesCaptureState): import("@anthropic-ai/claude-agent-sdk").McpSdkServerConfigWithInstance;

package/dist/phases/product-techniques/mcp-server.js

@@ -1,96 +0,0 @@
-/**
- * In-process MCP server exposing a single tool — `submit_techniques` — that
- * the Claude Agent SDK session calls to return the final markdown catalogue.
- *
- * Using a tool call instead of parsing a fenced JSON block lets the SDK
- * enforce the schema (via Zod) and lets the agent self-correct when
- * validation fails: the error message goes back as the tool result and the
- * agent can re-call the tool with corrected data.
- *
- * The capture pattern: callers pass in a `TechniquesCaptureState`. The tool
- * handler stores the validated args on `state.captured`. The orchestrator
- * reads it after the SDK loop ends.
- */
-import { createSdkMcpServer, tool } from '@anthropic-ai/claude-agent-sdk';
-import { z } from 'zod';
-import { TECHNIQUES_CONTENT_MAX, TECHNIQUES_SUMMARY_MAX, } from './types.js';
-export function createTechniquesCaptureState() {
-    return { captured: null };
-}
-/**
- * Validation that goes beyond the basic Zod schema: enforce that the
- * markdown actually has the H2 sections the prompt asks for. The agent gets
- * an actionable error and can re-submit.
- *
- * We don't require ALL six sections — agents on tiny repos often legitimately
- * collapse some. We require at least the first one ("Languages & Runtime")
- * plus "Notable Techniques", which the prompt calls out as the whole point.
- */
-export function validateContent(content) {
-    const required = [
-        /^##\s+Languages\s*&\s*Runtime\b/im,
-        /^##\s+Notable\s+Techniques\b/im,
-    ];
-    for (const re of required) {
-        if (!re.test(content)) {
-            return {
-                error: `content is missing the required section matching ${re.source}. Add the section and re-call submit_techniques.`,
-            };
-        }
-    }
-    return { error: null };
-}
-/**
- * Build the `submit_techniques` tool. Exported separately from the server
- * so tests can exercise the handler directly without going through MCP
- * transport.
- */
-export function createSubmitTechniquesTool(state) {
-    return tool('submit_techniques', [
-        'Submit the final techniques catalogue. Call this EXACTLY once, when',
-        'you have finished cataloguing every technique. Pass the summary and',
-        'the full markdown content as arguments. After this call succeeds, end',
-        'your turn — do NOT also paste the same content as a fenced code block.',
-        'If validation fails, the error message tells you what to fix; call the',
-        'tool again with corrected data.',
-    ].join(' '), {
-        summary: z
-            .string()
-            .min(1)
-            .max(TECHNIQUES_SUMMARY_MAX)
-            .describe('1-2 sentence summary suitable for a tab header. Plain text, no markdown.'),
-        content: z
-            .string()
-            .min(1)
-            .max(TECHNIQUES_CONTENT_MAX)
-            .describe('Full markdown body with H2 sections: Languages & Runtime, Frameworks & Libraries, Architecture Patterns, State & Data Techniques, Build & Deploy Techniques, Notable Techniques.'),
-    }, async (args) => {
-        const extraction = {
-            summary: args.summary,
-            content: args.content,
-        };
-        const { error } = validateContent(extraction.content);
-        if (error) {
-            return {
-                content: [{ type: 'text', text: error }],
-                isError: true,
-            };
-        }
-        state.captured = extraction;
-        return {
-            content: [
-                {
-                    type: 'text',
-                    text: `Captured techniques catalogue (${extraction.content.length} chars). End your turn now.`,
-                },
-            ],
-        };
-    });
-}
-export function createTechniquesMcpServer(state) {
-    return createSdkMcpServer({
-        name: 'product-techniques',
-        version: '1.0.0',
-        tools: [createSubmitTechniquesTool(state)],
-    });
-}

package/dist/phases/product-techniques/prompts.d.ts

@@ -1,19 +0,0 @@
-/**
- * Prompts for the product-level techniques phase.
- *
- * Agent's job: explore the cloned product repo and write a markdown catalogue
- * of the techniques it actually uses — languages, frameworks, patterns, state
- * idioms, build/deploy choices, plus the clever non-obvious bits. Focused on
- * what a new engineer needs to recognize and recreate, not feature lists.
- *
- * The final result is submitted via the `submit_techniques` MCP tool, NOT a
- * fenced JSON block. Tool calls let the SDK enforce the schema with Zod and
- * let the agent self-correct on validation errors. See mcp-server.ts.
- */
-export interface ProductTechniquesPromptContext {
-    productName: string;
-    productDescription?: string;
-    guidance?: string;
-}
-export declare function createProductTechniquesSystemPrompt(): string;
-export declare function createProductTechniquesUserPrompt(context: ProductTechniquesPromptContext): string;