Claude-Code-Workflow/.claude/skills/skill-simplify/phases/01-analysis.md

Phase 1: Functional Analysis

Read target file, extract functional inventory with code block classification, identify redundancy, validate pseudo-code format, and produce optimization plan.

Objective

• Build quantitative functional inventory with code block classification (baseline for Phase 3)
• Identify redundancy categories with specific line ranges
• Detect pseudo-code format issues
• Produce optimization plan with estimated line savings

Execution

Step 1.1: Read & Measure Target

const originalContent = Read(targetFile)
const lines = originalContent.split('\n')
const originalLineCount = lines.length

Step 1.2: Extract Functional Inventory

Count and catalog every functional element. These counts are the baseline for Phase 3 verification.

const inventory = {
  // Code structures — with role classification
  codeBlocks: [],        // { startLine, endLine, language, purpose, role: 'functional'|'descriptive' }
  agentCalls: [],        // { line, agentType, description, mergeGroup?: string }
  dataStructures: [],    // { line, name, type: 'object'|'array'|'schema' }

  // Logic elements
  routingBranches: [],   // { line, condition, outcomes[] }
  errorHandlers: [],     // { line, errorType, resolution }
  conditionalLogic: [],  // { line, condition, trueAction, falseAction }

  // Interface elements
  askUserQuestions: [],   // { line, questionCount, headers[], optionType: 'static'|'dynamic' }
  inputModes: [],        // { line, mode, description }
  outputArtifacts: [],   // { line, artifact, format }

  // Structural elements
  todoWriteBlocks: [],   // { line, phaseCount }
  phaseHandoffs: [],     // { line, fromPhase, toPhase }
  skillInvocations: [],  // { line, skillName, hasExecutionSteps: boolean }

  // Reference elements
  tables: [],            // { startLine, endLine, columns }
  schemas: [],           // { line, schemaName, fields[] }

  // Format issues
  formatIssues: [],      // { line, type, description, severity: 'error'|'warning' }

  // Totals (computed)
  counts: {}
}

Extraction rules:

• Code blocks: Match ```language ... ``` pairs, record start/end/language/first-line-as-purpose
• Agent calls: Match Agent(, Task(, subagent_type=, record type and prompt summary
• Data structures: Match const xxx = {, const xxx = [, JSON schema objects
• Routing branches: Match if/else, switch/case, ternary ? : with meaningful branching
• Error handlers: Match catch, error table rows | Error |, fallback patterns
• AskUserQuestion: Match AskUserQuestion({, count questions array length
• Input modes: Match Mode 1/2/3, --flag, argument parsing
• Output artifacts: Match Write(, Output:, file path patterns in comments
• TodoWrite: Match TodoWrite({, count todo items
• Phase handoffs: Match Read("phases/, Skill(, proceed_to_next_phase
• Tables: Match | header | markdown table blocks
• Schemas: Match schema references, JSON structure definitions

Step 1.2.1: Code Block Role Classification

For each code block, determine its role:

Role	Criteria	Examples
functional	Contains algorithm logic, routing branches, conditional code, agent calls, schema definitions, data processing, AskUserQuestion, Skill invocations	if/else, Agent({...}), const schema = {...}, Bash({...})
descriptive	Contains ASCII art, usage examples, display templates, illustrative good/bad comparisons, folder structure trees	┌───┐, # Example usage, ❌ Bad / ✅ Good, ├── file.ts

Classification rules:

• If block contains ANY of: Agent(, Bash(, AskUserQuestion(, if (, switch, Skill(, Write(, Read(, TodoWrite( → functional
• If block language is bash and content is only example invocations (no logic) → descriptive
• If block has no language tag and contains only ASCII box-drawing characters → descriptive
• If block is labeled as "Example" in surrounding markdown heading → descriptive
• Default: functional (conservative)

Step 1.2.2: Pseudo-Code Format Validation

Scan all functional code blocks for format issues:

Check	Detection	Severity
Nested backticks	Template literal ` inside ```javascript ``` code fence	warning
Unclosed brackets	Unmatched {, (, [ in code block	error
Undefined references	${variable} where variable is never declared in the block or prior blocks	warning
Inconsistent indentation	Mixed tabs/spaces or inconsistent nesting depth	warning
Dead code patterns	Commented-out code blocks (// if (, /* ... */ spanning 5+ lines)	warning
Missing return/output	Function-like block with no return, Write, or console.log	warning

inventory.formatIssues = validatePseudoCode(inventory.codeBlocks.filter(b => b.role === 'functional'))

Step 1.2.3: Compute Totals

inventory.counts = {
  codeBlocks: inventory.codeBlocks.length,
  functionalCodeBlocks: inventory.codeBlocks.filter(b => b.role === 'functional').length,
  descriptiveCodeBlocks: inventory.codeBlocks.filter(b => b.role === 'descriptive').length,
  agentCalls: inventory.agentCalls.length,
  dataStructures: inventory.dataStructures.length,
  routingBranches: inventory.routingBranches.length,
  errorHandlers: inventory.errorHandlers.length,
  conditionalLogic: inventory.conditionalLogic.length,
  askUserQuestions: inventory.askUserQuestions.length,
  inputModes: inventory.inputModes.length,
  outputArtifacts: inventory.outputArtifacts.length,
  todoWriteBlocks: inventory.todoWriteBlocks.length,
  phaseHandoffs: inventory.phaseHandoffs.length,
  skillInvocations: inventory.skillInvocations.length,
  tables: inventory.tables.length,
  schemas: inventory.schemas.length,
  formatIssues: inventory.formatIssues.length
}

Step 1.3: Identify Redundancy Categories

Scan for each category, record specific line ranges:

const redundancyMap = {
  deletable: [],       // { category, startLine, endLine, reason, estimatedSave }
  simplifiable: [],    // { category, startLine, endLine, strategy, estimatedSave }
  mergeable: [],       // { items: [{startLine, endLine}], mergeStrategy, estimatedSave }
  formatFixes: [],     // { line, type, fix }
  languageUnify: []    // { line, currentLang, targetLang }
}

Deletable (remove entirely, no functional loss):

Pattern	Detection
Duplicate Overview	## Overview that restates frontmatter description
ASCII flowchart	Flowchart that duplicates Phase Summary table or implementation structure
"When to use" section	Usage guidance not needed for execution
Best Practices section	Advisory content duplicating Core Rules
Duplicate examples	Code examples that repeat logic shown elsewhere
Folder structure duplicate	ASCII tree repeating Output Artifacts table
"Next Phase" paragraphs	Prose between phases when TodoWrite handles flow
Descriptive code blocks	Code blocks classified as descriptive whose content is covered by surrounding prose or tables

Simplifiable (compress, preserve meaning):

Pattern	Strategy
Verbose comments in code blocks	Reduce to single-line; keep only non-obvious logic comments
Multi-line console.log	Compress to single template literal
Wordy section intros	Remove "In this phase, we will..." preamble
Exploration prompt bloat	Trim to essential instructions, remove generic advice
Display-format code blocks	Convert code blocks that only define output format (console.log with template) to prose description

Mergeable (combine related structures):

Pattern	Strategy
Multiple similar AskUserQuestion calls	Extract shared function with mode parameter
Repeated Option routing	Unify into single dispatch
Sequential single-line operations	Combine into one code block
TodoWrite full blocks x N	Template once + delta comments
Duplicate error handling tables	Merge into single table
Equivalent template variants	Single/multi-perspective templates → one template with variant comment
Multiple output artifact tables	Merge into single combined table

Format fixes (pseudo-code quality):

Pattern	Fix
Nested backtick template literals	Convert surrounding code block to prose description, or use 4-backtick fence
Hardcoded option lists	Add comment: // Generate dynamically from {context source}
Workflow handoff without execution steps	Add execution steps referencing the target command's actual interface
Unclosed brackets	Fix bracket matching

Language unification:

• Detect mixed Chinese/English in functional comments
• Recommend consistent language (match majority)

Step 1.4: Build Optimization Plan

const optimizationPlan = {
  targetFile,
  originalLineCount,
  estimatedReduction: redundancyMap.deletable.reduce((s, d) => s + d.estimatedSave, 0)
    + redundancyMap.simplifiable.reduce((s, d) => s + d.estimatedSave, 0)
    + redundancyMap.mergeable.reduce((s, d) => s + d.estimatedSave, 0),
  categories: {
    deletable: { count: redundancyMap.deletable.length, totalLines: '...' },
    simplifiable: { count: redundancyMap.simplifiable.length, totalLines: '...' },
    mergeable: { count: redundancyMap.mergeable.length, totalLines: '...' },
    formatFixes: { count: redundancyMap.formatFixes.length },
    languageUnify: { count: redundancyMap.languageUnify.length }
  },
  // Ordered: delete → merge → simplify → format
  operations: [
    ...redundancyMap.deletable.map(d => ({ type: 'delete', ...d, priority: 1 })),
    ...redundancyMap.mergeable.map(m => ({ type: 'merge', ...m, priority: 2 })),
    ...redundancyMap.simplifiable.map(s => ({ type: 'simplify', ...s, priority: 3 })),
    ...redundancyMap.formatFixes.map(f => ({ type: 'format', ...f, priority: 4 }))
  ]
}

Display plan summary: category counts, estimated reduction percentage, sections NOT changed (functional core).

Output

• Variable: analysisResult = { inventory, redundancyMap, optimizationPlan, originalContent, originalLineCount }
• TodoWrite: Mark Phase 1 completed, Phase 2 in_progress