@compass-ai/nova 1.0.74 → 1.0.75

package/dist/prompts/workflow.js

@@ -1,608 +0,0 @@
-/**
- * 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

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