Code Problem Analyzer

Prerequisites

Required Information

1. Problem Context
   • Expected behavior: What should happen
   • Actual behavior: What actually happened
2. Problem-Related Information
   • Relevant logs, if available
   • Executed commands
   • Crash stack or error message
   • Configuration information, if relevant

Analysis Workflow

Step 1: Understand the Problem

1. Carefully read the problem context and identify the difference between the expected and actual behavior
2. Identify key information: commands, logs, error messages, and configuration-related items
3. Determine the analysis focus: execution flow, state, or configuration

Step 2: Code Exploration

• Start tracing from the user command or entry point
• Use

  grep

  to search for key functions, parameters, and flags
• Use

  read

  to examine key files and understand the call chain
• Track the passing and modification of key variables

• Search for state-related variables and functions, such as

  isDebugApp

  and

  isStartWithDebug

• Find the locations where state is set and read
• Analyze the state lifecycle and cleanup logic

• Find configuration-related code, such as

  GetBoolParam

  and

  GetApplicationInfo

• Analyze the sources and precedence of configuration values
• Check the configuration caching and update mechanisms

Step 3: Build a Flowchart

Entry Point → Function A → Function B → Key Decision Point → Result

• File path and line number
• Function name and key code snippet
• State changes or conditional checks

Step 4: Identify Possible Root Causes

1. Code logic errors: Conditional checks, loops, state transitions, and similar issues
2. State management issues: State not being properly initialized, cleaned up, or synchronized
3. Configuration issues: Incorrect configuration sources, unclear precedence, or invalid cache behavior
4. Timing issues: Asynchronous operations, race conditions, or callback ordering
5. Boundary conditions: Null pointers, out-of-bounds access, or unhandled exceptional cases

Step 5: Determine the Most Likely Root Cause

1. Strength of evidence: How much code and log evidence supports the hypothesis
2. Logical plausibility: Whether the cause can explain all observed behavior
3. Likelihood: Whether this type of problem commonly occurs in real-world development
4. Impact scope: Whether the cause covers all the key points mentioned by the user

Step 6: Pause When User Confirmation Is Needed

question

1. Multiple possible root causes: A unique root cause cannot be determined
2. Missing key information: More logs or configuration information are required
3. Hypothesis validation: The user needs to test or inspect specific conditions

question:
  questions:
    - question: "I found two possible causes: [Cause 1] and [Cause 2]. To confirm further, please provide:"
      header: "More information needed"
      options:
        - label: "Check the configuration file"
          description: "Check the debug field value in the application configuration file"
        - label: "View the full logs"
          description: "Provide the full application startup logs"
        - label: "Check the pending debug list"
          description: "Run the aa appdebug get command to view the pending debug status"

Output Format

Standard Output

## Problem Analysis Results

### All Possible Flows

1. **Flow 1**: [Flow description]
   - File:file.cpp:line number - [Key code snippet]
   - File:file.cpp:line number - [Key code snippet]
   - ...

2. **Flow 2**: [Flow description]
   - File:file.cpp:line number - [Key code snippet]
   - ...

### Most Likely Root Cause

**Root Cause**: [Clear root-cause description]

**Explanation**:
- [Explanation 1]
- [Explanation 2]
- [Key code location]: file.cpp:line number

**Suggested Solution**:
1. [Solution 1]
2. [Solution 2]

### Further Confirmation Required

[If needed, explain what the user needs to do]

Concise Output (if the issue is clear)

## Problem Analysis Results

### Most Likely Root Cause

**Root Cause**: [Clear root-cause description]

**Reason**: [Brief explanation]

**Key Code Location**: file.cpp:line number

**Solution**: [Specific action steps]

Best Practices

Code Search Strategies

1. Start with key parameters: If the user mentions a parameter or flag, search for it first
2. Trace the call chain: Start from the entry point and work through each layer
3. Pay attention to state changes: Find the locations where state variables are set, read, and modified
4. Look for conditional checks: Conditional branches are often the key to the problem

Code Reading Techniques

1. Read function signatures and comments first: Understand the inputs, outputs, and purpose of each function
2. Focus on key logic: Conditional checks, loops, and state transitions
3. Trace the data flow: Follow how variables are passed and modified
4. Understand the context: Determine the circumstances under which a function is called

Building a Flowchart

1. Start from the user command: This is the clearest entry point
2. Mark key decision points: Conditional checks and state inspections
3. Record state changes: How variable values change
4. Annotate file locations: Include the file and line number for every step

Validating Hypotheses

1. Check all observed behavior: Determine whether the hypothesis explains all observations
2. Look for counterexamples: Check for evidence that contradicts the hypothesis
3. Consider boundary cases: Determine whether the hypothesis holds under special conditions
4. Evaluate impact scope: Check whether the hypothesis covers all key points mentioned by the user

Common Problem Patterns

State Management Issues

• State is used before being initialized
• State changes are not synchronized with related components
• State is not thoroughly cleaned up, leaving residual data
• Multiple locations modify the same state, resulting in inconsistency

Configuration Issues

• The configuration source is unclear, such as command-line arguments versus configuration files or default values
• Configuration precedence is confused
• Configuration caches are not updated in a timely manner
• Configuration validation is missing

Timing Issues

• Asynchronous operations are not awaited correctly
• Callback execution order does not match expectations
• Events are triggered at an incorrect time
• Resources are released at an inappropriate time

References

• ANALYSIS_METHODOLOGY.md - In-depth code analysis methodology
• OUTPUT_FORMAT.md - Output format specifications and examples