@defai.digital/ax-cli 3.8.29 → 3.8.33

package/README.md

@@ -93,6 +93,7 @@ ax-cli
 - **Code Smell Detector** - 10+ anti-patterns detection
 - **Hotspot Analyzer** - Git history-based complexity analysis
 - **Security Scanner** - SQL injection, XSS, hardcoded secrets
+- **Multi-Language Support** - TypeScript, JavaScript, Python, Rust, Go, C, C++, Swift, HTML, CSS
 
 ---
 
@@ -381,7 +382,35 @@ Email: **security@defai.digital** (private disclosure)
 
 ## Changelog
 
-### v3.8.29 (Latest)
+### v3.8.33 (Latest)
+
+- **Bug fix: Dead code detection** - Fixed ts-morph source file lifecycle management for semantic analysis
+- **Improved AST parser** - `getSourceFile()` now properly preserves files for `findReferencesAsNodes()` operations
+- **CI/CD stability** - Resolved test failures in dead code detector tests
+
+### v3.8.32
+
+- **Auto-Thinking Mode** - GLM-4.6 automatically enables reasoning mode for complex tasks (debugging, architecture, refactoring)
+- **Smart complexity detection** - Uses `shouldUseThinkingMode()` and `getComplexityScore()` to detect when extended reasoning helps
+- **Enhanced /usage command** - Estimated session cost, cache hit rate, and detailed token breakdown
+- **User preference respect** - Auto-thinking only activates when user hasn't explicitly set thinking preference
+
+### v3.8.31
+
+- **Multi-language AST parsing** - Tree-sitter integration for Python, Rust, Go, C, C++, Swift, HTML, CSS
+- **Unified parser facade** - `MultiLanguageParser` automatically routes to appropriate parser (ts-morph for TS/JS, tree-sitter for others)
+- **Updated analyzers** - DependencyAnalyzer, MetricsAnalyzer, HotspotDetector, CodeSmellDetector now support all languages
+- **Polyglot code analysis** - Analyze mixed-language codebases with single command
+
+### v3.8.30
+
+- **Project Status Report template** - Comprehensive template with metrics, risks, and progress tracking
+- **Technical Specification template** - Detailed design docs with API, data model, and architecture sections
+- **Changelog Generation guidelines** - Standard categories and git commands for release notes
+- **PRD Refinement workflow** - Iterative improvement process with stakeholder feedback integration
+- **Bug fix: multiEdit audit logging** - Fixed inverted boolean in audit log for multi-edit operations
+
+### v3.8.29
 
 - **ADR (Architecture Decision Record) template** - Complete template for documenting architectural decisions
 - **Self-verification pattern** - Quality checklists for code, analysis, and documentation

package/config-defaults/prompts.yaml

@@ -556,6 +556,302 @@ system_prompt:
         - If partial changes fail, note which files were modified
         - Provide user with recovery steps if needed
 
+    # Project Status Report template
+    project_status_report:
+      title: "PROJECT STATUS REPORT"
+      content: |
+        When asked to create a project status report or progress update:
+
+        === STATUS REPORT TEMPLATE ===
+        # Project Status Report
+        **Date**: [YYYY-MM-DD]
+        **Reporting Period**: [Start Date] to [End Date]
+        **Author**: [Name/Role]
+
+        ## Executive Summary
+        2-3 sentences summarizing overall project health and key highlights.
+        Status: 🟢 On Track | 🟡 At Risk | 🔴 Blocked
+
+        ## Progress Overview
+
+        ### Completed This Period
+        | Task | Files Changed | Impact |
+        |------|--------------|--------|
+        | [Task 1] | [files] | [impact] |
+
+        ### In Progress
+        | Task | % Complete | ETA | Blockers |
+        |------|-----------|-----|----------|
+        | [Task 1] | [%] | [date] | [blockers] |
+
+        ### Planned Next Period
+        - [ ] Task 1
+        - [ ] Task 2
+
+        ## Metrics
+
+        ### Code Metrics
+        - Files modified: [N]
+        - Lines added: [+N]
+        - Lines removed: [-N]
+        - Test coverage: [N%]
+
+        ### Quality Metrics
+        - Open bugs: [N] (Critical: [N], Major: [N], Minor: [N])
+        - Technical debt items: [N]
+        - Code review turnaround: [N hours/days]
+
+        ## Risks and Blockers
+
+        | Risk/Blocker | Severity | Mitigation | Owner |
+        |--------------|----------|------------|-------|
+        | [Issue] | High/Med/Low | [Action] | [Name] |
+
+        ## Dependencies
+        - External: [List external dependencies and their status]
+        - Internal: [List internal team dependencies]
+
+        ## Decisions Needed
+        1. [Decision 1]: [Options and recommendation]
+        2. [Decision 2]: [Options and recommendation]
+
+        ## Next Steps
+        1. [Immediate action 1]
+        2. [Immediate action 2]
+        === END TEMPLATE ===
+
+        GATHERING DATA:
+        1. Run `git log --oneline --since="[period]"` for commit history
+        2. Run `git diff --stat [start]..HEAD` for file changes
+        3. Check issue tracker for open/closed items
+        4. Review test results for coverage metrics
+
+        RULES:
+        - Use actual data from codebase, not estimates
+        - Be specific about blockers and risks
+        - Include actionable next steps
+        - Keep executive summary concise
+
+    # Technical Specification template
+    technical_specification:
+      title: "TECHNICAL SPECIFICATION"
+      content: |
+        When asked to create a technical spec or detailed design:
+
+        === TECHNICAL SPEC TEMPLATE ===
+        # Technical Specification: [Feature Name]
+
+        ## Metadata
+        - **Author**: [Name]
+        - **Created**: [Date]
+        - **Status**: Draft | Review | Approved
+        - **Related PRD**: [Link to PRD if exists]
+
+        ## Overview
+        Brief description of what this specification covers.
+
+        ## Goals
+        - Primary goal
+        - Secondary goals
+
+        ## Non-Goals
+        - What this does NOT cover
+
+        ## System Architecture
+
+        ### Component Diagram
+        ```
+        [Component A] --> [Component B] --> [Component C]
+              |                                   |
+              v                                   v
+        [Database]                          [External API]
+        ```
+
+        ### Data Flow
+        1. User action triggers [Component A]
+        2. [Component A] validates and sends to [Component B]
+        3. ...
+
+        ## API Design
+
+        ### Endpoints (if applicable)
+        ```
+        POST /api/v1/[resource]
+        Request:
+          {
+            "field1": "string",
+            "field2": number
+          }
+        Response:
+          {
+            "id": "string",
+            "status": "created"
+          }
+        ```
+
+        ### Function Signatures (if applicable)
+        ```typescript
+        function processData(input: InputType): Promise<OutputType>
+        ```
+
+        ## Data Model
+
+        ### Entities
+        ```typescript
+        interface Entity {
+          id: string;
+          createdAt: Date;
+          // ... fields
+        }
+        ```
+
+        ### Database Schema (if applicable)
+        ```sql
+        CREATE TABLE entities (
+          id UUID PRIMARY KEY,
+          created_at TIMESTAMP DEFAULT NOW()
+        );
+        ```
+
+        ## Error Handling
+        | Error Code | Condition | User Message | Recovery |
+        |------------|-----------|--------------|----------|
+        | E001 | [condition] | [message] | [action] |
+
+        ## Security Considerations
+        - Authentication: [method]
+        - Authorization: [rules]
+        - Data validation: [approach]
+        - Known risks: [list]
+
+        ## Performance Requirements
+        - Latency: < [N]ms for [operation]
+        - Throughput: [N] requests/second
+        - Memory: < [N]MB per [unit]
+
+        ## Testing Strategy
+        - Unit tests: [scope]
+        - Integration tests: [scope]
+        - E2E tests: [scope]
+
+        ## Rollout Plan
+        1. Phase 1: [scope] - [criteria]
+        2. Phase 2: [scope] - [criteria]
+
+        ## Rollback Plan
+        - Trigger: [conditions]
+        - Steps: [actions]
+        === END TEMPLATE ===
+
+        RULES:
+        - Research existing architecture FIRST
+        - Include actual code examples, not pseudocode
+        - Specify concrete numbers for performance requirements
+        - Link to existing code files where relevant
+
+    # Changelog Generation guidelines
+    changelog_generation:
+      title: "CHANGELOG GENERATION"
+      content: |
+        When asked to generate a changelog or release notes:
+
+        === CHANGELOG TEMPLATE ===
+        # Changelog
+
+        ## [Version] - YYYY-MM-DD
+
+        ### Added
+        - New feature 1 (#PR)
+        - New feature 2 (#PR)
+
+        ### Changed
+        - Updated behavior of X (#PR)
+        - Improved performance of Y (#PR)
+
+        ### Fixed
+        - Bug fix 1 (#PR)
+        - Bug fix 2 (#PR)
+
+        ### Deprecated
+        - Feature X will be removed in version Y
+
+        ### Removed
+        - Removed deprecated feature Z
+
+        ### Security
+        - Security fix for CVE-XXXX
+        === END TEMPLATE ===
+
+        CATEGORIZATION RULES:
+        - Added: Wholly new features or capabilities
+        - Changed: Modifications to existing behavior
+        - Fixed: Bug fixes (user-facing issues)
+        - Deprecated: Features marked for future removal
+        - Removed: Features that were removed
+        - Security: Security-related fixes
+
+        GATHERING DATA:
+        ```bash
+        # Get commits since last tag
+        git log $(git describe --tags --abbrev=0)..HEAD --oneline
+
+        # Get commits by type (if using conventional commits)
+        git log --oneline | grep -E "^[a-f0-9]+ (feat|fix|docs):"
+        ```
+
+        USER-FACING FOCUS:
+        - Emphasize what users can DO differently
+        - Avoid internal implementation details
+        - Include migration steps for breaking changes
+        - Link to documentation for new features
+
+    # PRD Refinement workflow
+    prd_refinement:
+      title: "PRD REFINEMENT"
+      content: |
+        When iterating on a PRD or design document:
+
+        REFINEMENT WORKFLOW:
+        1. REVIEW existing PRD sections
+        2. IDENTIFY gaps or ambiguities
+        3. RESEARCH codebase for constraints
+        4. UPDATE specific sections
+        5. VALIDATE changes don't conflict
+
+        COMMON REFINEMENT TRIGGERS:
+        - "Make this more specific"
+        - "Add technical constraints"
+        - "Consider edge case X"
+        - "Incorporate feedback from [stakeholder]"
+
+        REFINEMENT CHECKLIST:
+        □ Problem Statement: Is it clear and measurable?
+        □ Goals: Are they SMART (Specific, Measurable, Achievable, Relevant, Time-bound)?
+        □ Non-Goals: Are boundaries explicit?
+        □ Technical Requirements: Based on actual codebase?
+        □ Risks: Realistic with mitigations?
+        □ Success Metrics: Quantifiable?
+
+        VERSION TRACKING:
+        ```
+        ## Revision History
+        | Version | Date | Author | Changes |
+        |---------|------|--------|---------|
+        | 1.0 | [date] | [author] | Initial draft |
+        | 1.1 | [date] | [author] | Added X based on feedback |
+        ```
+
+        STAKEHOLDER FEEDBACK INTEGRATION:
+        - Tag feedback source: "[Feedback from Engineering]"
+        - Track open questions: "❓ Needs clarification: [question]"
+        - Mark decisions: "✅ Decided: [decision] ([rationale])"
+
+        ITERATION BEST PRACTICES:
+        - Make focused changes (one concern per iteration)
+        - Preserve original intent while adding specificity
+        - Document why changes were made
+        - Re-validate affected sections
+
   closing: "Be direct. Be accurate. Be brief."
 
 # Custom instructions handling

package/dist/agent/llm-agent.d.ts

@@ -31,6 +31,10 @@ export declare class LLMAgent extends EventEmitter {
     private samplingConfig;
     /** Thinking/reasoning mode configuration */
     private thinkingConfig;
+    /** Track if auto-thinking was enabled for current message (for UI indicator) */
+    private autoThinkingEnabled;
+    /** User's explicit thinking preference (undefined = auto, true/false = explicit) */
+    private userThinkingPreference;
     /** Stored reference to context overflow listener for proper cleanup */
     private contextOverflowListener;
     /** Track if agent has been disposed */
@@ -61,16 +65,30 @@ export declare class LLMAgent extends EventEmitter {
     /**
      * Set thinking/reasoning mode configuration for this agent session
      * @param config Thinking configuration to apply (enabled/disabled)
+     * @param isUserExplicit Whether this is an explicit user preference (vs auto-detection)
      */
-    setThinkingConfig(config: ThinkingConfig | undefined): void;
+    setThinkingConfig(config: ThinkingConfig | undefined, isUserExplicit?: boolean): void;
     /**
      * Get current thinking configuration
      */
     getThinkingConfig(): ThinkingConfig | undefined;
+    /**
+     * Check if auto-thinking was enabled for the current message
+     * Used by UI to show indicator when thinking was auto-activated
+     */
+    isAutoThinkingEnabled(): boolean;
     /**
      * Get current sampling configuration
      */
     getSamplingConfig(): SamplingConfig | undefined;
+    /**
+     * Apply auto-thinking mode detection for a user message
+     * Only activates if user hasn't explicitly set a preference
+     *
+     * @param message User's message text
+     * @returns true if thinking mode was auto-enabled, false otherwise
+     */
+    private applyAutoThinking;
     /**
      * Enable or disable tool approval requirement
      * When enabled, text_editor operations will emit 'tool:approval_required' events

package/dist/agent/llm-agent.js

@@ -12,7 +12,7 @@ import { buildSystemPrompt } from "../utils/prompt-builder.js";
 import { extractErrorMessage } from "../utils/error-handler.js";
 import { getCheckpointManager } from "../checkpoint/index.js";
 import { SubagentOrchestrator } from "./subagent-orchestrator.js";
-import { getTaskPlanner, isComplexRequest, } from "../planner/index.js";
+import { getTaskPlanner, isComplexRequest, shouldUseThinkingMode, getComplexityScore, } from "../planner/index.js";
 // Note: TaskPhase now used by PlanExecutor (Phase 2 refactoring)
 import { PLANNER_CONFIG } from "../constants.js";
 import { resolveMCPReferences, extractMCPReferences } from "../mcp/resources.js";
@@ -57,6 +57,10 @@ export class LLMAgent extends EventEmitter {
     samplingConfig;
     /** Thinking/reasoning mode configuration */
     thinkingConfig;
+    /** Track if auto-thinking was enabled for current message (for UI indicator) */
+    autoThinkingEnabled = false;
+    /** User's explicit thinking preference (undefined = auto, true/false = explicit) */
+    userThinkingPreference = undefined;
     /** Stored reference to context overflow listener for proper cleanup */
     contextOverflowListener;
     /** Track if agent has been disposed */
@@ -226,9 +230,15 @@ export class LLMAgent extends EventEmitter {
     /**
      * Set thinking/reasoning mode configuration for this agent session
      * @param config Thinking configuration to apply (enabled/disabled)
+     * @param isUserExplicit Whether this is an explicit user preference (vs auto-detection)
      */
-    setThinkingConfig(config) {
+    setThinkingConfig(config, isUserExplicit = true) {
         this.thinkingConfig = config;
+        // Track user's explicit preference to respect their choice over auto-detection
+        if (isUserExplicit) {
+            this.userThinkingPreference = config?.type === 'enabled' ? true :
+                config?.type === 'disabled' ? false : undefined;
+        }
     }
     /**
      * Get current thinking configuration
@@ -236,12 +246,57 @@ export class LLMAgent extends EventEmitter {
     getThinkingConfig() {
         return this.thinkingConfig;
     }
+    /**
+     * Check if auto-thinking was enabled for the current message
+     * Used by UI to show indicator when thinking was auto-activated
+     */
+    isAutoThinkingEnabled() {
+        return this.autoThinkingEnabled;
+    }
     /**
      * Get current sampling configuration
      */
     getSamplingConfig() {
         return this.samplingConfig;
     }
+    /**
+     * Apply auto-thinking mode detection for a user message
+     * Only activates if user hasn't explicitly set a preference
+     *
+     * @param message User's message text
+     * @returns true if thinking mode was auto-enabled, false otherwise
+     */
+    applyAutoThinking(message) {
+        // Reset auto-thinking state
+        this.autoThinkingEnabled = false;
+        // If user has explicit preference, respect it
+        if (this.userThinkingPreference !== undefined) {
+            return false;
+        }
+        // Check if model supports thinking mode
+        const model = this.llmClient.getCurrentModel();
+        const modelLower = model.toLowerCase();
+        const supportsThinking = modelLower.includes('glm') || modelLower.includes('4.6');
+        if (!supportsThinking) {
+            return false;
+        }
+        // Check if message would benefit from thinking mode
+        if (shouldUseThinkingMode(message)) {
+            const complexity = getComplexityScore(message);
+            // Only auto-enable for moderately complex or higher tasks
+            if (complexity >= 25) {
+                this.thinkingConfig = { type: 'enabled' };
+                this.autoThinkingEnabled = true;
+                // Emit event for UI to show indicator
+                this.emit('auto_thinking_enabled', {
+                    complexity,
+                    message: message.substring(0, 100)
+                });
+                return true;
+            }
+        }
+        return false;
+    }
     /**
      * Enable or disable tool approval requirement
      * When enabled, text_editor operations will emit 'tool:approval_required' events
@@ -840,6 +895,8 @@ export class LLMAgent extends EventEmitter {
     async processUserMessage(message) {
         // Check if agent has been disposed
         this.checkDisposed();
+        // GLM-4.6 OPTIMIZATION: Auto-enable thinking mode for complex tasks
+        this.applyAutoThinking(message);
         // Reset tool call tracking for new message
         this.resetToolCallTracking();
         // Resolve MCP resource references (Phase 4)
@@ -1165,6 +1222,16 @@ export class LLMAgent extends EventEmitter {
     async *processUserMessageStream(message) {
         // Create new abort controller for this request
         this.abortController = new AbortController();
+        // GLM-4.6 OPTIMIZATION: Auto-enable thinking mode for complex tasks
+        // This detects requests that would benefit from extended reasoning
+        const autoThinkingApplied = this.applyAutoThinking(message);
+        if (autoThinkingApplied) {
+            // Notify UI that thinking mode was auto-enabled
+            yield {
+                type: "content",
+                content: "🧠 *Auto-thinking enabled for complex task*\n\n"
+            };
+        }
         // Check if this is a complex request that should use multi-phase planning
         if (this.shouldCreatePlan(message)) {
             // Delegate to planning processor