@compass-ai/nova 1.0.73 → 1.0.74

package/dist/prompts/workflow.js

@@ -0,0 +1,608 @@
+/**
+ * Workflow prompts for the planning and execution system.
+ *
+ * These templates are used for LLM interactions during the workflow phases.
+ * Templates use {{variable}} syntax for interpolation.
+ *
+ * The classification prompts are designed to be domain-agnostic, supporting both
+ * development tasks and productivity automation via MCP tools.
+ */
+import { interpolateTemplate } from './utils.js';
+import { DEFAULT_PERSONALITY_MODE } from '../constants/index.js';
+import * as os from 'os';
+import { execSync } from 'child_process';
+import { getPreferredShell } from '../services/shell-executor.js';
+/**
+ * Prompt template for context analysis - analyzes codebase structure
+ * to understand its architecture and find relevant files.
+ *
+ * Variables:
+ * - {{userRequest}} - The user's request
+ * - {{projectType}} - Type of project (Node.js, React, etc.)
+ * - {{languages}} - Languages detected in the project
+ * - {{projectRoot}} - Root directory of the project
+ * - {{directoryTree}} - Directory structure
+ */
+export const CONTEXT_ANALYSIS_PROMPT = `
+You are analyzing a codebase to understand its structure and find files relevant to a user request.
+
+## User Request
+{{userRequest}}
+
+## Project Information
+- Type: {{projectType}}
+- Languages: {{languages}}
+- Root: {{projectRoot}}
+
+## Directory Structure
+{{directoryTree}}
+
+## Task
+Analyze the project structure and identify:
+1. Which areas of the codebase are likely affected (UI, backend, database, tests, etc.)
+2. Key files that should be examined
+3. Potential dependencies or related files
+4. Any configuration that might need updating
+
+Provide a structured analysis.
+`;
+/**
+ * Prompt template for complexity assessment - determines the best execution approach.
+ *
+ * Variables:
+ * - {{userRequest}} - The user's request
+ * - {{filesCount}} - Number of files potentially affected
+ * - {{affectedAreas}} - Areas of the codebase affected
+ * - {{recentChanges}} - Recent changes in the codebase
+ */
+export const COMPLEXITY_ASSESSMENT_PROMPT = `
+You are assessing the complexity of a development task to determine the best execution approach.
+
+## User Request
+{{userRequest}}
+
+## Context Summary
+- Files potentially affected: {{filesCount}}
+- Areas affected: {{affectedAreas}}
+- Recent changes in codebase: {{recentChanges}}
+
+## Assessment Criteria
+
+**Simple/Direct Mode** - Execute immediately without planning:
+- 1-3 files affected
+- Less than 50 lines changed
+- Clear, unambiguous requirements
+- No architectural changes
+- No breaking changes
+
+**Clarification Needed** - Requires user input first:
+- Ambiguous requirements
+- Multiple valid approaches
+- User preferences needed
+- Missing information
+
+**Plan Mode Required** - Needs detailed implementation plan:
+- 4+ files affected
+- 100+ lines of changes
+- Architectural changes
+- Breaking changes possible
+- Cross-cutting concerns
+
+## Task
+Analyze the request and determine:
+1. Which mode is appropriate
+2. Key complexity factors
+3. If clarification needed, what questions to ask
+4. Estimated effort level
+`;
+/**
+ * Prompt template for plan generation - creates detailed implementation plans.
+ *
+ * Variables:
+ * - {{userRequest}} - The user's request
+ * - {{contextSummary}} - Summary of the gathered context
+ * - {{clarificationSummary}} - Summary of user clarifications (if any)
+ */
+export const PLAN_GENERATION_PROMPT = `
+You are creating a detailed implementation plan for a development task.
+
+## User Request
+{{userRequest}}
+
+## Context
+{{contextSummary}}
+
+## Clarification Answers (if any)
+{{clarificationSummary}}
+
+## Requirements
+Generate a comprehensive implementation plan with:
+
+1. **Problem Statement** - Clear description of what we're building and why
+
+2. **Requirements Analysis**
+   - Extract explicit requirements from user request
+   - Infer implicit requirements
+   - Reference clarification answers where applicable
+
+3. **Edge Cases** - Identify potential edge cases and how to handle them
+
+4. **Impact Assessment**
+   - Files to create/modify/delete
+   - Dependencies affected
+   - Breaking changes if any
+   - Migration needs
+
+5. **Task Breakdown**
+   For each task include:
+   - Clear description
+   - Target files and specific code sections
+   - Dependencies on other tasks
+   - Verification criteria
+
+6. **Risk Analysis**
+   - Potential issues
+   - Mitigation strategies
+   - Rollback approach
+
+7. **Testing Requirements**
+   - Unit tests needed
+   - Integration tests needed
+   - Manual testing steps
+
+Ensure tasks are ordered by dependencies and each task is atomic and independently verifiable.
+`;
+/**
+ * Prompt template for verification - verifies implementation matches its plan.
+ *
+ * Variables:
+ * - {{planSummary}} - Summary of the original plan
+ * - {{executionResults}} - Results of the implementation
+ * - {{diffSummary}} - Summary of changes made
+ */
+export const VERIFICATION_PROMPT = `
+You are verifying that an implementation matches its plan.
+
+## Original Plan
+{{planSummary}}
+
+## Implementation Results
+{{executionResults}}
+
+## Changes Made
+{{diffSummary}}
+
+## Verification Tasks
+1. Verify each planned task was completed correctly
+2. Check for orphaned or incomplete code
+3. Verify all requirements are addressed
+4. Check alignment with clarification answers
+5. Identify any deviations from the plan
+
+Provide a detailed verification report.
+`;
+/**
+ * Prompt template for LLM-based complexity classification decision.
+ *
+ * This prompt presents all gathered factors and heuristic analysis to the LLM,
+ * allowing it to make the final decision about execution mode with full context.
+ *
+ * Variables:
+ * - {{userRequest}} - The user's request
+ * - {{filesAffected}} - Number of files potentially affected
+ * - {{linesChanged}} - Estimated lines to be changed
+ * - {{requirementsClear}} - Whether requirements are clear (true/false)
+ * - {{architecturalChange}} - Whether this involves architectural changes
+ * - {{breakingChanges}} - Whether this may cause breaking changes
+ * - {{crossCuttingConcerns}} - Whether multiple subsystems are affected
+ * - {{createsAbstractions}} - Whether new abstractions will be created
+ * - {{requiresMigration}} - Whether data migration is needed
+ * - {{implementationApproaches}} - Number of valid implementation approaches
+ * - {{riskLevel}} - Risk level (1-10)
+ * - {{heuristicMode}} - What the rule-based system suggests
+ * - {{heuristicConfidence}} - Confidence of heuristic suggestion (0-100)
+ * - {{heuristicReasoning}} - Reasoning from heuristic analysis
+ * - {{affectedAreas}} - Codebase areas affected
+ * - {{relevantFiles}} - Key files identified
+ */
+export const LLM_COMPLEXITY_CLASSIFICATION_PROMPT = `You are determining the appropriate execution mode for a development task.
+
+## Execution Modes
+
+**DIRECT** - Execute immediately without planning:
+- Simple, focused changes (1-3 files, <50 lines)
+- Clear, unambiguous requirements with single obvious approach
+- No architectural impact, no breaking changes
+- Low risk (e.g., typo fixes, simple bug fixes, adding logs)
+- **Requests to understand, explain, or analyze existing code** - the codebase needs to be explored thoroughly
+
+**NO_ACTION** - Nothing needs to be done:
+- The requested feature/change is already fully implemented in the codebase
+- The request doesn't make sense given the current code structure or project context
+- The request conflicts with existing functionality or architecture in a way that makes it invalid
+- **NOT for requests to understand, explain, analyze, or explore existing code** - those need DIRECT mode to properly search the codebase
+- When using this mode: provide clear explanation of why no action is needed, and offer a helpful follow-up question or tip to guide the user
+
+**TODO_LIST** - Create a simple task checklist:
+- Medium complexity tasks (2-8 files, 30-200 lines)
+- Requirements are clear OR sufficient code context is available to proceed
+- No architectural changes or breaking changes
+- Multiple sequential steps that benefit from tracking
+- Moderate risk level (not too simple, not too complex)
+- PREFER this mode when code snippets/files have been analyzed and provide sufficient context
+- Good for: adding a feature across a few files, implementing a well-defined component, updating multiple related files
+
+**PLAN** - Requires detailed implementation plan:
+- Large refactoring across many existing files (4+ files, 100+ lines)
+- Architectural modifications to existing systems
+- Breaking changes or migrations of existing data/APIs
+- High risk changes to production code
+- Cross-cutting concerns affecting multiple existing subsystems
+
+**PLAN_ADOPT** - User has already provided a structured plan:
+- Input contains numbered steps, ordered tasks, or a clear implementation sequence
+- Often comes from user approving/refining a previous LLM suggestion
+- Indicators: "1.", "2.", "3." sequence, bullet points with specific actions, task lists
+- Your job: validate feasibility, enrich with technical details, format to schema
+- PRESERVE user's task order and descriptions - do NOT regenerate or reorder
+- Use this when the user's input already IS the plan, not just a request FOR a plan
+
+## Important Guidance
+- **TODO_LIST is the balanced default** for medium-complexity tasks when code context is available. It provides structure without over-planning.
+- **Default to DIRECT for simple tasks** and TODO_LIST for multi-step tasks - the agentic loop has AskUserQuestion tool available for questions during execution
+- For **new programs/scripts**: Use TODO_LIST if the request is reasonably specific
+- PLAN is mainly for **modifying existing complex codebases** with architectural changes, not for greenfield development
+- When in doubt between TODO_LIST and PLAN, prefer TODO_LIST if there are no architectural changes
+- **PLAN_ADOPT saves time** when users provide structured input - don't regenerate what they've already defined
+
+## User Request
+{{userRequest}}
+
+## Analyzed Complexity Factors
+| Factor | Value |
+|--------|-------|
+| Files likely affected | {{filesAffected}} |
+| Estimated lines changed | {{linesChanged}} |
+| Requirements clear | {{requirementsClear}} |
+| Context sufficiency | {{contextSufficiency}} |
+| Architectural change | {{architecturalChange}} |
+| Breaking changes | {{breakingChanges}} |
+| Cross-cutting concerns | {{crossCuttingConcerns}} |
+| Creates abstractions | {{createsAbstractions}} |
+| Requires migration | {{requiresMigration}} |
+| Implementation approaches | {{implementationApproaches}} |
+| Risk level | {{riskLevel}}/10 |
+
+## Heuristic Analysis (Rule-Based)
+- **Suggested Mode**: {{heuristicMode}}
+- **Confidence**: {{heuristicConfidence}}%
+- **Reasoning**: {{heuristicReasoning}}
+
+## Codebase Context
+- **Affected Areas**: {{affectedAreas}}
+- **Key Files**: {{relevantFiles}}
+
+## Your Task
+Analyze the request and factors above. Consider:
+1. Does the heuristic suggestion make sense, or does context warrant a different mode?
+2. **Context sufficiency is key**: If context sufficiency is "medium" or "high", prefer TODO_LIST.
+3. Are there nuances the rules might miss (e.g., security implications, hidden complexity)?
+4. Default to DIRECT for simple tasks, TODO_LIST for multi-step tasks, PLAN only for genuine architectural complexity
+
+## Reasoning Guidelines
+Your reasoning should be **concise and actionable**:
+- State the key insight about what's needed to proceed
+- Do NOT list multiple interpretations ("The user could mean: (1)..., (2)..., (3)...")
+- Do NOT enumerate possibilities or reflect on ambiguity
+- Focus on **what information is missing** or **why the chosen mode is appropriate**
+
+## Response Format
+
+**CRITICAL**: You MUST respond with ONLY valid JSON wrapped in a markdown code block. Your response will be parsed with JSON.parse().
+
+\`\`\`json
+{
+  "mode": "TODO_LIST",
+  "confidence": 80,
+  "reasoning": "Medium complexity task with clear implementation path.",
+  "agreesWithHeuristic": true
+}
+\`\`\`
+
+**Field Requirements:**
+- **mode** (required): Exactly one of: "NO_ACTION", "DIRECT", "TODO_LIST", "PLAN", "PLAN_ADOPT"
+- **confidence** (required): Number 0-100 (integer, no quotes)
+- **reasoning** (required): String with 1-2 concise sentences
+- **agreesWithHeuristic** (required): Boolean (true or false, no quotes)
+- **noActionExplanation** (conditional): String, ONLY if mode is "NO_ACTION"
+- **adoptedPlanSummary** (conditional): String, ONLY if mode is "PLAN_ADOPT"
+
+**Common Mistakes:**
+- Do NOT use "DIRECT" | "TODO_LIST" - choose ONE mode
+- Do NOT use <number> or <boolean> - use actual values
+- Do NOT include conditional fields unless their condition applies`;
+// =============================================================================
+// CLASSIFIER PERSONALITY GUIDELINES
+// =============================================================================
+/**
+ * Classifier-specific personality guidelines.
+ * These are lighter-weight than the main prompt personalities, focused on
+ * how the classifier should reason and communicate its analysis.
+ */
+export const CLASSIFIER_PERSONALITY_GUIDELINES = {
+    professional: `## Communication Style
+- Be concise and direct in your reasoning (1-2 sentences)
+- Focus on actionable insights, not listing possibilities
+- State the key factors that drove your decision
+- Avoid hedging or over-qualifying your assessment`,
+    brutally_honest: `## Communication Style
+- Be blunt and direct - no hedging, no "might be" or "could be"
+- One sentence reasoning max unless something is genuinely complex
+- Call out bad practices or unclear requests directly
+- Don't soften your assessment to be polite`,
+    verbose_analyst: `## Communication Style
+- Explain your reasoning process step by step
+- Discuss what factors you weighed and why
+- Mention alternatives you considered if relevant
+- Provide context for your decision
+- It's okay to be thorough - understanding matters more than brevity`,
+};
+/**
+ * Gets the classifier personality guidelines for a given mode.
+ */
+export function getClassifierPersonalityGuidelines(mode) {
+    return CLASSIFIER_PERSONALITY_GUIDELINES[mode] || CLASSIFIER_PERSONALITY_GUIDELINES.professional;
+}
+// =============================================================================
+// REFACTORED SYSTEM PROMPT (contains all static instructions)
+// =============================================================================
+/**
+ * System prompt for LLM-first classification.
+ * This establishes the LLM's role as a task complexity analyzer.
+ *
+ * Contains all static content that can be cached:
+ * - Role definition
+ * - Execution mode definitions
+ * - Decision guidelines
+ * - Response format specification
+ * - Personality guidelines (interpolated)
+ * - Directory structure (interpolated)
+ *
+ * Variables:
+ * - {{personalityGuidelines}} - Communication style based on personality mode
+ * - {{directoryTree}} - Directory structure of the project
+ */
+export const LLM_FIRST_CLASSIFICATION_SYSTEM_PROMPT = `You are a task complexity analyzer for a CLI assistant that handles both development tasks and productivity automation.
+
+Your role is to examine user requests and available context to determine the optimal execution approach.
+
+{{personalityGuidelines}}
+
+## Available External Tools
+{{availableMCPTools}}
+
+## Available Sub-Agents
+{{availableSubAgents}}
+
+## System Information
+{{systemInfo}}
+
+## Execution Modes
+
+**NO_ACTION** - Nothing needs to be done:
+- The requested feature/change is already fully implemented
+- The request doesn't make sense given the current context
+- **IMPORTANT**: Do NOT use NO_ACTION just because there are no relevant code files. If the request can be accomplished via available MCP tools, use DIRECT or TODO_LIST instead.
+- **NOT for requests to understand, explain, analyze, or explore** - those need DIRECT mode
+- When using this mode: provide clear explanation of why no action is needed, and offer a helpful follow-up question or tip to guide the user
+
+**DIRECT** - Execute immediately without planning:
+- Simple, focused tasks with clear implementation path
+- Examples for code: renaming a variable, fixing a typo, adding a log statement
+- Examples for external tools: creating a single meeting, sending an email, running a web search
+- **Requests to understand, explain, or analyze existing content**
+- Clear implementation path, no design decisions needed
+
+**TODO_LIST** - Create a simple task checklist:
+- Medium complexity tasks (3-6 files or multiple steps)
+- Clear requirements with straightforward implementation
+- No architectural changes, but multiple steps to track
+- Good for: well-defined features, multi-step workflows, sequential tasks
+
+**PLAN** - Requires detailed implementation plan:
+- Genuinely complex architectural changes
+- Multiple interdependent systems affected
+- Breaking changes or risky modifications
+- Complex coordination required across multiple components
+
+**PLAN_ADOPT** - User has already provided a structured plan:
+- Input contains numbered steps, ordered tasks, or a clear implementation sequence
+- Often comes from user approving/refining a previous LLM suggestion
+- Indicators: "1.", "2.", "3." sequence, "first... then... finally", bullet points with specific actions, task lists
+- Your job: validate feasibility, enrich with technical details (file paths, IDs, dependencies), format to schema
+- PRESERVE user's task order and descriptions - do NOT regenerate or reorder unless dependencies are clearly wrong
+- Use this when the user's input already IS the plan, not just a request FOR a plan
+
+**SPAWN_AGENT** - Delegate to a specialized sub-agent:
+- Task matches the specialization of an available sub-agent (see Available Sub-Agents section above)
+- Sub-agent can handle the task more efficiently than the main agentic loop
+- Examples: codebase exploration, code review, debugging, planning
+- Benefits: reduced context usage, specialized expertise, isolated execution
+- When using this mode: specify which agent to spawn and provide a refined task description
+- The sub-agent will be invoked automatically via the spawn_task tool
+
+## Decision Guidelines
+
+### For Code Tasks:
+- **Don't be fooled by file count.** 20 files with the same simple change = DIRECT. 3 files with complex interdependencies = PLAN.
+- **Look at the actual code.** Are these files genuinely interconnected, or just keyword matches?
+- **When in doubt:** prefer TODO_LIST/DIRECT. The agent has AskUserQuestion tool for questions during execution.
+
+### For External Tool Tasks (MCP/automation):
+- If the task can be accomplished with available MCP tools, it's a valid task
+- Simple single-action tasks (create meeting, send email) = DIRECT
+- Multi-step workflows = TODO_LIST
+
+### General:
+- **Default to DIRECT or TODO_LIST** - The agent can ask questions during execution via AskUserQuestion tool as needed
+- **TODO_LIST** is great for medium-complexity tasks with clear requirements - simpler than PLAN but provides tracking
+- **PLAN is for genuine complexity**, not bureaucratic overhead
+- **PLAN_ADOPT saves time** when users provide structured input - don't regenerate what they've already defined
+
+## Response Format
+
+Respond with JSON conforming to the provided schema. Include only fields relevant to the chosen mode.
+
+## Project Directory Structure
+{{directoryTree}}`;
+/**
+ * User prompt template for LLM-first classification.
+ *
+ * Contains only the request-specific, dynamic data. All static instructions
+ * (mode definitions, guidelines, response format) are in the system prompt
+ * for better caching and token efficiency.
+ *
+ * Variables:
+ * - {{userRequest}} - The user's request
+ * - {{projectType}} - Type of project
+ * - {{languages}} - Languages in the project
+ * - {{fileCount}} - Total files gathered
+ * - {{affectedAreas}} - Detected codebase areas
+ */
+export const LLM_FIRST_CLASSIFICATION_PROMPT = `## User Request
+{{userRequest}}
+
+## Project Context
+- **Type:** {{projectType}}
+- **Languages:** {{languages}}
+- **Files gathered:** {{fileCount}}
+- **Affected Areas:** {{affectedAreas}}`;
+/**
+ * Prompt template for rollback analysis - analyzes rollback strategy.
+ *
+ * Variables:
+ * - {{planSummary}} - Summary of the plan
+ * - {{fileOperations}} - File operations performed
+ * - {{commits}} - Git commits made
+ */
+export const ROLLBACK_ANALYSIS_PROMPT = `
+Analyze the rollback strategy for this implementation plan.
+
+## Plan Summary
+{{planSummary}}
+
+## File Operations
+{{fileOperations}}
+
+## Git Commits
+{{commits}}
+
+## Task
+Determine the safest rollback approach:
+1. Order of operations to undo changes
+2. Data migration reversals if applicable
+3. Dependencies to consider
+4. Potential data loss warnings
+`;
+/**
+ * All workflow prompt templates exported as a collection.
+ */
+export const WORKFLOW_PROMPTS = {
+    contextAnalysis: CONTEXT_ANALYSIS_PROMPT,
+    complexityAssessment: COMPLEXITY_ASSESSMENT_PROMPT,
+    llmComplexityClassification: LLM_COMPLEXITY_CLASSIFICATION_PROMPT,
+    llmFirstClassification: LLM_FIRST_CLASSIFICATION_PROMPT,
+    llmFirstClassificationSystem: LLM_FIRST_CLASSIFICATION_SYSTEM_PROMPT,
+    classifierPersonalityGuidelines: CLASSIFIER_PERSONALITY_GUIDELINES,
+    planGeneration: PLAN_GENERATION_PROMPT,
+    verification: VERIFICATION_PROMPT,
+    rollbackAnalysis: ROLLBACK_ANALYSIS_PROMPT,
+};
+/**
+ * Helper functions for workflow prompts
+ */
+export const WorkflowPromptHelpers = {
+    /**
+     * Interpolates the context analysis prompt with variables.
+     */
+    buildContextAnalysisPrompt: (variables) => interpolateTemplate(CONTEXT_ANALYSIS_PROMPT, variables),
+    /**
+     * Interpolates the complexity assessment prompt with variables.
+     */
+    buildComplexityAssessmentPrompt: (variables) => interpolateTemplate(COMPLEXITY_ASSESSMENT_PROMPT, variables),
+    /**
+     * Interpolates the plan generation prompt with variables.
+     */
+    buildPlanGenerationPrompt: (variables) => interpolateTemplate(PLAN_GENERATION_PROMPT, variables),
+    /**
+     * Interpolates the verification prompt with variables.
+     */
+    buildVerificationPrompt: (variables) => interpolateTemplate(VERIFICATION_PROMPT, variables),
+    /**
+     * Interpolates the rollback analysis prompt with variables.
+     */
+    buildRollbackAnalysisPrompt: (variables) => interpolateTemplate(ROLLBACK_ANALYSIS_PROMPT, variables),
+    /**
+     * Interpolates the LLM complexity classification prompt with all factors.
+     */
+    buildLLMComplexityClassificationPrompt: (variables) => interpolateTemplate(LLM_COMPLEXITY_CLASSIFICATION_PROMPT, variables),
+    /**
+     * Interpolates the LLM-first classification user prompt.
+     * Contains only dynamic data - all static instructions are in the system prompt.
+     */
+    buildLLMFirstClassificationPrompt: (variables) => interpolateTemplate(LLM_FIRST_CLASSIFICATION_PROMPT, variables),
+    /**
+     * Builds the complete system prompt for LLM-first classification.
+     * Includes personality guidelines for consistent tone with the main assistant.
+     */
+    /**
+     * Gathers current system information for injection into the prompt.
+     */
+    getSystemInfo(workingDirectory) {
+        const cwd = workingDirectory || process.cwd();
+        // Check if directory is a git repo
+        let isGitRepo = false;
+        try {
+            execSync('git rev-parse --is-inside-work-tree', {
+                cwd,
+                stdio: 'pipe',
+                encoding: 'utf-8'
+            });
+            isGitRepo = true;
+        }
+        catch {
+            isGitRepo = false;
+        }
+        // Get platform
+        const platform = process.platform;
+        // Get OS version
+        const osVersion = `${os.type()} ${os.release()}`;
+        // Get preferred shell (uses cached detection from shell-executor)
+        const shell = getPreferredShell();
+        // Get today's date in YYYY-MM-DD format
+        const today = new Date().toISOString().split('T')[0];
+        return `Working directory: ${cwd}
+Is directory a git repo: ${isGitRepo ? 'Yes' : 'No'}
+Platform: ${platform}
+OS Version: ${osVersion}
+Shell: ${shell}
+Today's date: ${today}`;
+    },
+    /**
+     * Builds the complete system prompt for LLM-first classification.
+     * Includes personality guidelines for consistent tone with the main assistant.
+     */
+    buildClassifierSystemPrompt: (options) => {
+        const { personalityMode = DEFAULT_PERSONALITY_MODE, directoryTree = 'Directory structure not available', availableMCPTools = 'No external tools currently connected.', availableSubAgents = 'No specialized sub-agents are currently available.', workingDirectory, } = options;
+        const personalityGuidelines = getClassifierPersonalityGuidelines(personalityMode);
+        const systemInfo = WorkflowPromptHelpers.getSystemInfo(workingDirectory);
+        return interpolateTemplate(LLM_FIRST_CLASSIFICATION_SYSTEM_PROMPT, {
+            personalityGuidelines,
+            directoryTree,
+            availableMCPTools,
+            availableSubAgents,
+            systemInfo,
+        });
+    },
+};
+//# sourceMappingURL=workflow.js.map

package/dist/prompts/workflow.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"workflow.js","sourceRoot":"","sources":["../../src/prompts/workflow.ts"],"names":[],"mappings":"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"}