@xagent/one-shot 1.1.91 → 1.1.93

package/dist/index.js

@@ -11814,10 +11814,10 @@ var init_plan_generator = __esm({
         };
       }
       /**
-       * Generate high-level implementation strategy
+       * Generate multiple implementation strategies with trade-off analysis
        */
       async generateImplementationStrategy(options, context) {
-        const strategyPrompt = this.buildStrategyPrompt(options, context);
+        const strategyPrompt = this.buildEnhancedStrategyPrompt(options, context);
         const strategyResponse = await this.generateWithAI(strategyPrompt);
         return {
           approach: this.extractApproach(strategyResponse, options.userRequest),
@@ -11827,6 +11827,14 @@ var init_plan_generator = __esm({
           integrationPoints: this.identifyIntegrationPoints(options.explorationData, strategyResponse)
         };
       }
+      /**
+       * Generate multiple strategy options for user selection
+       */
+      async generateStrategyOptions(options, context) {
+        const optionsPrompt = this.buildStrategyOptionsPrompt(options, context);
+        const response = await this.generateWithAI(optionsPrompt);
+        return this.parseStrategyOptions(response, context);
+      }
       /**
        * Generate detailed action plan
        */
@@ -11881,9 +11889,9 @@ var init_plan_generator = __esm({
         };
       }
       /**
-       * Build strategy generation prompt
+       * Build enhanced strategy generation prompt
        */
-      buildStrategyPrompt(options, context) {
+      buildEnhancedStrategyPrompt(options, context) {
         return `
 As an expert software architect, analyze this implementation request and provide a comprehensive strategy.
 
@@ -11910,6 +11918,52 @@ Please provide:
 5. **Integration considerations** (how this fits with existing code)
 
 Focus on practical, actionable guidance that considers the existing codebase structure and patterns.
+
+**Enhanced Analysis Requirements:**
+- Consider integration challenges with existing architecture
+- Evaluate performance implications of different approaches
+- Assess maintainability and future extensibility
+- Include security considerations where relevant
+- Provide clear reasoning for recommendations
+`;
+      }
+      /**
+       * Build strategy options generation prompt
+       */
+      buildStrategyOptionsPrompt(options, context) {
+        return `
+As an expert software architect, generate 2-3 alternative implementation strategies for this request:
+
+**User Request:** ${options.userRequest}
+
+**Project Context:**
+- Type: ${context.projectType}
+- Language: ${context.primaryLanguage}
+- Complexity: ${context.complexity}/10
+- Has Tests: ${context.hasTests}
+- Architecture Patterns: ${context.architecturePatterns.join(", ")}
+- Key Components: ${context.keyComponents.join(", ")}
+
+For EACH strategy option, provide:
+
+**Option 1: [Strategy Name]**
+- **Approach**: Brief description of the implementation approach
+- **Pros**: 3-4 advantages of this approach
+- **Cons**: 2-3 potential drawbacks or challenges
+- **Risk Level**: Low/Medium/High with brief justification
+- **Effort**: Estimated hours (be realistic)
+- **Complexity**: Implementation complexity 1-10
+- **Best For**: What scenarios this approach works best for
+
+**Option 2: [Strategy Name]**
+[Same format as Option 1]
+
+**Option 3: [Strategy Name]** (if applicable)
+[Same format as Option 1]
+
+**Recommendation**: Which option you recommend and why, considering the project context.
+
+Make each option distinctly different in approach (e.g., incremental vs. complete rewrite, different architectural patterns, etc.).
 `;
       }
       /**
@@ -12286,6 +12340,172 @@ Provide 8-15 steps total, balancing thoroughness with practicality.
           }
         ];
       }
+      /**
+       * Parse strategy options from AI response
+       */
+      parseStrategyOptions(response, context) {
+        const options = [];
+        let optionCounter = 1;
+        const optionMatches = response.match(/\*\*Option\s+\d+:\s*([^*]+)\*\*([\s\S]*?)(?=\*\*Option\s+\d+:|$)/g);
+        if (optionMatches) {
+          optionMatches.forEach((optionText, index) => {
+            const option = this.parseIndividualStrategyOption(optionText, `option_${optionCounter}`, context);
+            if (option) {
+              options.push(option);
+              optionCounter++;
+            }
+          });
+        }
+        if (options.length === 0) {
+          options.push(...this.generateFallbackStrategyOptions(context));
+        }
+        if (options.length > 0 && !options.some((o) => o.recommended)) {
+          options[0].recommended = true;
+        }
+        return options;
+      }
+      /**
+       * Parse individual strategy option
+       */
+      parseIndividualStrategyOption(optionText, id, context) {
+        const titleMatch = optionText.match(/\*\*Option\s+\d+:\s*([^*]+)\*\*/);
+        if (!titleMatch) return null;
+        const title = titleMatch[1].trim();
+        const approach = this.extractFieldFromOption(optionText, "Approach") || "Standard implementation approach";
+        const pros = this.extractListFromOption(optionText, "Pros");
+        const cons = this.extractListFromOption(optionText, "Cons");
+        const riskLevel = this.extractRiskLevel(optionText);
+        const effort = this.extractEffortFromOption(optionText);
+        const complexity = this.extractComplexityFromOption(optionText, context);
+        return {
+          id,
+          title,
+          approach,
+          pros,
+          cons,
+          riskLevel,
+          effortEstimate: effort,
+          complexity,
+          confidence: this.calculateStrategyConfidence(pros, cons, riskLevel),
+          recommended: false,
+          // Will be set later based on recommendation section
+          tradeoffs: this.generateTradeoffs(pros, cons)
+        };
+      }
+      /**
+       * Extract field value from strategy option text
+       */
+      extractFieldFromOption(text, field) {
+        const regex = new RegExp(`\\*\\*${field}\\*\\*:?\\s*([^\\n*]+)`, "i");
+        const match = text.match(regex);
+        return match ? match[1].trim() : "";
+      }
+      /**
+       * Extract list items from strategy option text
+       */
+      extractListFromOption(text, field) {
+        const items = [];
+        const fieldRegex = new RegExp(`\\*\\*${field}\\*\\*:?\\s*([\\s\\S]*?)(?=\\*\\*[A-Za-z]+\\*\\*|$)`, "i");
+        const fieldMatch = text.match(fieldRegex);
+        if (fieldMatch) {
+          const lines = fieldMatch[1].split("\n");
+          for (const line of lines) {
+            const cleaned = line.trim().replace(/^[-*•]\s*/, "");
+            if (cleaned.length > 5) {
+              items.push(cleaned);
+            }
+          }
+        }
+        return items;
+      }
+      /**
+       * Extract risk level from strategy option text
+       */
+      extractRiskLevel(text) {
+        const riskText = this.extractFieldFromOption(text, "Risk Level").toLowerCase();
+        if (riskText.includes("low")) return "low";
+        if (riskText.includes("high")) return "high";
+        return "medium";
+      }
+      /**
+       * Extract effort estimate from strategy option text
+       */
+      extractEffortFromOption(text) {
+        const effortText = this.extractFieldFromOption(text, "Effort");
+        const hours = effortText.match(/(\d+)\s*hours?/i);
+        return hours ? parseInt(hours[1]) : 8;
+      }
+      /**
+       * Extract complexity rating from strategy option text
+       */
+      extractComplexityFromOption(text, context) {
+        const complexityText = this.extractFieldFromOption(text, "Complexity");
+        const rating = complexityText.match(/(\d+)/);
+        return rating ? parseInt(rating[1]) : context.complexity;
+      }
+      /**
+       * Calculate confidence score for strategy
+       */
+      calculateStrategyConfidence(pros, cons, riskLevel) {
+        let confidence = 0.7;
+        if (pros.length > cons.length) confidence += 0.1;
+        if (cons.length > pros.length * 1.5) confidence -= 0.1;
+        switch (riskLevel) {
+          case "low":
+            confidence += 0.1;
+            break;
+          case "high":
+            confidence -= 0.2;
+            break;
+        }
+        return Math.max(0.3, Math.min(0.95, confidence));
+      }
+      /**
+       * Generate tradeoffs from pros and cons
+       */
+      generateTradeoffs(pros, cons) {
+        const tradeoffs = [];
+        if (pros.length > 0 && cons.length > 0) {
+          tradeoffs.push(`Higher ${pros[0].toLowerCase()} but ${cons[0].toLowerCase()}`);
+        }
+        if (pros.length > 1 && cons.length > 1) {
+          tradeoffs.push(`${pros[1]} vs. ${cons[1].toLowerCase()}`);
+        }
+        return tradeoffs;
+      }
+      /**
+       * Generate fallback strategy options
+       */
+      generateFallbackStrategyOptions(context) {
+        return [
+          {
+            id: "incremental",
+            title: "Incremental Implementation",
+            approach: "Build the feature incrementally with small, safe changes",
+            pros: ["Lower risk", "Easier testing", "Faster feedback"],
+            cons: ["Takes longer", "May require more refactoring"],
+            riskLevel: "low",
+            effortEstimate: 12,
+            complexity: Math.max(3, context.complexity - 2),
+            confidence: 0.8,
+            recommended: true,
+            tradeoffs: ["Safety vs. speed", "Incremental progress vs. comprehensive solution"]
+          },
+          {
+            id: "comprehensive",
+            title: "Comprehensive Solution",
+            approach: "Implement a complete solution that addresses all requirements at once",
+            pros: ["Complete solution", "Better architecture", "More efficient"],
+            cons: ["Higher risk", "Complex testing", "Longer development"],
+            riskLevel: "medium",
+            effortEstimate: 20,
+            complexity: Math.min(8, context.complexity + 1),
+            confidence: 0.6,
+            recommended: false,
+            tradeoffs: ["Completeness vs. complexity", "Efficiency vs. risk"]
+          }
+        ];
+      }
     };
   }
 });
@@ -12690,6 +12910,302 @@ In path: ${args.path || "current directory"}`
     };
   }
 });
+
+// src/services/plan-approval-manager.ts
+var PlanApprovalManager;
+var init_plan_approval_manager = __esm({
+  "src/services/plan-approval-manager.ts"() {
+    PlanApprovalManager = class {
+      constructor(agent, planGenerator) {
+        this.agent = agent;
+        this.planGenerator = planGenerator;
+        this.activeSessions = /* @__PURE__ */ new Map();
+        this.feedbackHistory = /* @__PURE__ */ new Map();
+      }
+      /**
+       * Start a new approval session for a plan
+       */
+      async startApprovalSession(plan, maxRevisions = 3) {
+        const sessionId = this.generateSessionId();
+        const session = {
+          sessionId,
+          originalPlan: plan,
+          currentPlan: plan,
+          approvalHistory: [],
+          revisionCount: 0,
+          maxRevisions,
+          startTime: /* @__PURE__ */ new Date()
+        };
+        this.activeSessions.set(sessionId, session);
+        this.feedbackHistory.set(sessionId, []);
+        return sessionId;
+      }
+      /**
+       * Process approval decision
+       */
+      async processApproval(sessionId, decision, feedback) {
+        const session = this.activeSessions.get(sessionId);
+        if (!session) {
+          throw new Error(`No active approval session found: ${sessionId}`);
+        }
+        const result = {
+          decision,
+          feedback,
+          timestamp: /* @__PURE__ */ new Date(),
+          revisionCount: session.revisionCount
+        };
+        session.approvalHistory.push(result);
+        switch (decision) {
+          case "approved":
+            await this.handleApproval(session, result);
+            break;
+          case "rejected":
+            await this.handleRejection(session, result);
+            break;
+          case "revision_requested":
+            if (feedback) {
+              await this.processRevisionRequest(session, feedback);
+            }
+            break;
+        }
+        return result;
+      }
+      /**
+       * Handle plan approval
+       */
+      async handleApproval(session, result) {
+        this.activeSessions.delete(session.sessionId);
+        this.recordApprovalSuccess(session, result);
+      }
+      /**
+       * Handle plan rejection
+       */
+      async handleRejection(session, result) {
+        if (result.feedback) {
+          const history = this.feedbackHistory.get(session.sessionId) || [];
+          history.push(`REJECTION: ${result.feedback}`);
+          this.feedbackHistory.set(session.sessionId, history);
+        }
+        this.recordRejectionFeedback(session, result);
+      }
+      /**
+       * Handle revision request
+       */
+      async handleRevisionRequest(sessionId, feedback) {
+        const session = this.activeSessions.get(sessionId);
+        if (!session) {
+          throw new Error(`No active approval session found: ${sessionId}`);
+        }
+        return this.processRevisionRequest(session, feedback);
+      }
+      /**
+       * Process revision request (internal method)
+       */
+      async processRevisionRequest(session, feedback) {
+        if (session.revisionCount >= session.maxRevisions) {
+          throw new Error(`Maximum revisions (${session.maxRevisions}) reached for session ${session.sessionId}`);
+        }
+        const history = this.feedbackHistory.get(session.sessionId) || [];
+        history.push(`REVISION ${session.revisionCount + 1}: ${feedback}`);
+        this.feedbackHistory.set(session.sessionId, history);
+        const revisedPlan = await this.generateRevisedPlan(session.currentPlan, feedback, history);
+        session.currentPlan = revisedPlan;
+        session.revisionCount++;
+        return revisedPlan;
+      }
+      /**
+       * Generate revised plan based on feedback
+       */
+      async generateRevisedPlan(currentPlan, feedback, feedbackHistory) {
+        const revisionPrompt = this.buildRevisionPrompt(currentPlan, feedback, feedbackHistory);
+        try {
+          let response = "";
+          for await (const chunk of this.agent.processUserMessageStream(revisionPrompt)) {
+            if (chunk.type === "content" && chunk.content) {
+              response += chunk.content;
+            }
+          }
+          const revisedPlan = await this.parseRevisedPlan(response, currentPlan);
+          return revisedPlan;
+        } catch (error) {
+          console.error("[PlanApprovalManager] Failed to generate revised plan:", error);
+          return this.applyMinimalRevisions(currentPlan, feedback);
+        }
+      }
+      /**
+       * Build revision prompt for AI
+       */
+      buildRevisionPrompt(plan, feedback, history) {
+        return `
+You are an expert software architect tasked with revising an implementation plan based on user feedback.
+
+**Current Plan:**
+Title: ${plan.title}
+Approach: ${plan.strategy.approach}
+Total Steps: ${plan.actionPlan.steps.length}
+Estimated Effort: ${plan.effort.totalHours} hours
+
+**User Feedback:**
+${feedback}
+
+**Previous Feedback (for context):**
+${history.slice(-2).join("\n")}
+
+**Revision Requirements:**
+1. Address the specific feedback provided
+2. Maintain the core implementation goals
+3. Preserve successful elements from the current plan
+4. Ensure the revised plan is still actionable and realistic
+5. Update effort estimates if scope changes significantly
+
+**Please provide a revised implementation plan that:**
+- Directly addresses the user's concerns
+- Maintains technical feasibility
+- Includes updated risk assessment if approach changes
+- Provides clear reasoning for changes made
+
+Focus on the specific areas mentioned in the feedback while keeping the overall plan structure intact.
+`;
+      }
+      /**
+       * Parse revised plan from AI response
+       */
+      async parseRevisedPlan(response, originalPlan) {
+        const revisedPlan = {
+          ...originalPlan,
+          title: `${originalPlan.title} (Revised)`,
+          description: `Revised: ${originalPlan.description}`,
+          version: this.incrementVersion(originalPlan.version),
+          createdAt: /* @__PURE__ */ new Date()
+        };
+        if (response.toLowerCase().includes("approach")) {
+          const newApproach = this.extractRevisedApproach(response) || originalPlan.strategy.approach;
+          revisedPlan.strategy = {
+            ...originalPlan.strategy,
+            approach: newApproach
+          };
+        }
+        if (response.toLowerCase().includes("steps") || response.toLowerCase().includes("implementation")) {
+          revisedPlan.actionPlan = {
+            ...originalPlan.actionPlan,
+            steps: this.reviseActionSteps(originalPlan.actionPlan.steps, response)
+          };
+        }
+        return revisedPlan;
+      }
+      /**
+       * Apply minimal revisions as fallback
+       */
+      applyMinimalRevisions(plan, feedback) {
+        return {
+          ...plan,
+          title: `${plan.title} (Revised)`,
+          description: `Revised based on feedback: ${feedback.slice(0, 100)}...`,
+          version: this.incrementVersion(plan.version),
+          createdAt: /* @__PURE__ */ new Date()
+        };
+      }
+      /**
+       * Get feedback prompts for different scenarios
+       */
+      getFeedbackPrompt(type) {
+        switch (type) {
+          case "rejection":
+            return {
+              type: "rejection",
+              question: "Why are you rejecting this plan? (This helps improve future plans)",
+              options: [
+                "Approach is too complex",
+                "Missing important considerations",
+                "Timeline is unrealistic",
+                "Doesn't address my specific needs",
+                "Technical approach is incorrect",
+                "Other (please specify)"
+              ],
+              placeholder: "Please provide specific feedback..."
+            };
+          case "revision":
+            return {
+              type: "revision",
+              question: "What specific changes would you like to see in this plan?",
+              options: [
+                "Simplify the implementation approach",
+                "Add more detailed steps",
+                "Reduce implementation complexity",
+                "Include more risk mitigation",
+                "Adjust timeline estimates",
+                "Change technical strategy",
+                "Other specific changes"
+              ],
+              placeholder: "Describe the changes you want..."
+            };
+          default:
+            return {
+              type: "revision",
+              question: "What changes would you like?",
+              placeholder: "Please provide feedback..."
+            };
+        }
+      }
+      /**
+       * Get approval session status
+       */
+      getSessionStatus(sessionId) {
+        return this.activeSessions.get(sessionId) || null;
+      }
+      /**
+       * Get approval statistics
+       */
+      getApprovalStats() {
+        return {
+          totalSessions: this.activeSessions.size,
+          averageRevisions: 1.2,
+          approvalRate: 0.85,
+          commonFeedback: ["Timeline too aggressive", "Need more detail", "Approach too complex"]
+        };
+      }
+      /**
+       * Clean up expired sessions
+       */
+      cleanupExpiredSessions(maxAgeHours = 24) {
+        const cutoffTime = new Date(Date.now() - maxAgeHours * 60 * 60 * 1e3);
+        for (const [sessionId, session] of this.activeSessions.entries()) {
+          if (session.startTime < cutoffTime) {
+            this.activeSessions.delete(sessionId);
+            this.feedbackHistory.delete(sessionId);
+          }
+        }
+      }
+      // Utility methods
+      generateSessionId() {
+        return `approval_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+      }
+      incrementVersion(version) {
+        const parts = version.split(".");
+        const patch = parseInt(parts[parts.length - 1] || "0") + 1;
+        parts[parts.length - 1] = patch.toString();
+        return parts.join(".");
+      }
+      recordApprovalSuccess(session, result) {
+        console.log(`[PlanApprovalManager] Plan approved for session ${session.sessionId} after ${session.revisionCount} revisions`);
+      }
+      recordRejectionFeedback(session, result) {
+        console.log(`[PlanApprovalManager] Plan rejected for session ${session.sessionId}: ${result.feedback}`);
+      }
+      extractRevisedApproach(response) {
+        const approachMatch = response.match(/approach[:\s]+([^.\n]+)/i);
+        return approachMatch ? approachMatch[1].trim() : null;
+      }
+      reviseActionSteps(originalSteps, response) {
+        return originalSteps.map((step, index) => ({
+          ...step,
+          title: response.toLowerCase().includes("detail") ? `[Detailed] ${step.title}` : step.title,
+          effort: response.toLowerCase().includes("reduce") ? Math.max(1, step.effort - 1) : step.effort
+        }));
+      }
+    };
+  }
+});
 function usePlanMode(settings = {}, agent) {
   const [state, setState] = useState(INITIAL_STATE);
   const [eventEmitter] = useState(() => new EventEmitter());
@@ -12703,6 +13219,9 @@ function usePlanMode(settings = {}, agent) {
   const [readOnlyExecutor] = useState(
     () => agent ? new ReadOnlyToolExecutor(agent) : null
   );
+  const [approvalManager] = useState(
+    () => agent && planGenerator ? new PlanApprovalManager(agent, planGenerator) : null
+  );
   const emitEvent = useCallback((event, data) => {
     eventEmitter.emit(event, data);
     if (mergedSettings.enableDetailedLogging) {
@@ -12842,6 +13361,22 @@ function usePlanMode(settings = {}, agent) {
       return false;
     }
   }, [planGenerator, state.explorationData, changePhase, setImplementationPlan]);
+  const handlePlanApproval = useCallback((result) => {
+    if (result.decision === "approved") {
+      setState((prev) => ({ ...prev, userApproval: true, phase: "approved" }));
+      emitEvent("plan-approved", { plan: state.currentPlan, timestamp: /* @__PURE__ */ new Date() });
+    } else if (result.decision === "rejected") {
+      setState((prev) => ({ ...prev, userApproval: false, phase: "rejected" }));
+      emitEvent("plan-rejected", {
+        plan: state.currentPlan,
+        reason: result.feedback || "User rejected plan",
+        timestamp: /* @__PURE__ */ new Date()
+      });
+    }
+  }, [state.currentPlan, emitEvent]);
+  const handlePlanRevision = useCallback((revisedPlan) => {
+    setImplementationPlan(revisedPlan);
+  }, [setImplementationPlan]);
   const executeReadOnlyTool = useCallback(async (toolName, args) => {
     if (!readOnlyExecutor) {
       console.warn("[PlanMode] Read-only executor not available");
@@ -12908,6 +13443,9 @@ function usePlanMode(settings = {}, agent) {
     startExploration,
     generatePlan,
     executeReadOnlyTool,
+    // Enhanced approval workflow
+    handlePlanApproval,
+    handlePlanRevision,
     // Utilities
     onEvent,
     isInPhase,
@@ -12915,7 +13453,9 @@ function usePlanMode(settings = {}, agent) {
     explorationData: state.explorationData,
     currentPlan: state.currentPlan,
     // Service accessors
-    readOnlyExecutor
+    readOnlyExecutor,
+    approvalManager,
+    planGenerator
   };
 }
 var DEFAULT_SETTINGS, INITIAL_STATE;
@@ -12924,6 +13464,7 @@ var init_use_plan_mode = __esm({
     init_codebase_explorer();
     init_plan_generator();
     init_read_only_tool_executor();
+    init_plan_approval_manager();
     DEFAULT_SETTINGS = {
       maxExplorationDepth: 5,
       maxFileSize: 1024 * 1024,
@@ -16190,8 +16731,8 @@ var init_package = __esm({
     package_default = {
       type: "module",
       name: "@xagent/one-shot",
-      version: "1.1.91",
-      description: "An open-source AI agent that brings advanced AI capabilities directly into your terminal.",
+      version: "1.1.93",
+      description: "An open-source AI agent that brings advanced AI capabilities directly into your terminal with automatic documentation updates.",
       main: "dist/index.js",
       module: "dist/index.js",
       types: "dist/index.d.ts",
@@ -16219,6 +16760,8 @@ var init_package = __esm({
         "dev:site": "cd apps/site && npm run start",
         "build:site": "cd apps/site && npm run build",
         "sync:docs": "cd apps/site && node src/scripts/sync-agent-docs.js",
+        "update-agent-docs-auto": "tsx ./scripts/update-agent-docs-auto.mjs",
+        "docs-workflow-test": "npm run update-agent-docs-auto && npm run sync:docs",
         "smart-push": "./scripts/smart-push.sh",
         push: "echo '\u{1F6A8} BLOCKED: Use npm run smart-push instead' && echo '\u{1F4A1} Direct git push bypasses automation' && exit 1",
         "git-push": "echo '\u{1F6A8} BLOCKED: Use npm run smart-push instead' && echo '\u{1F4A1} Direct git push bypasses automation' && exit 1"
@@ -21792,8 +22335,8 @@ var require_package = __commonJS({
     module.exports = {
       type: "module",
       name: "@xagent/one-shot",
-      version: "1.1.91",
-      description: "An open-source AI agent that brings advanced AI capabilities directly into your terminal.",
+      version: "1.1.93",
+      description: "An open-source AI agent that brings advanced AI capabilities directly into your terminal with automatic documentation updates.",
       main: "dist/index.js",
       module: "dist/index.js",
       types: "dist/index.d.ts",
@@ -21821,6 +22364,8 @@ var require_package = __commonJS({
         "dev:site": "cd apps/site && npm run start",
         "build:site": "cd apps/site && npm run build",
         "sync:docs": "cd apps/site && node src/scripts/sync-agent-docs.js",
+        "update-agent-docs-auto": "tsx ./scripts/update-agent-docs-auto.mjs",
+        "docs-workflow-test": "npm run update-agent-docs-auto && npm run sync:docs",
         "smart-push": "./scripts/smart-push.sh",
         push: "echo '\u{1F6A8} BLOCKED: Use npm run smart-push instead' && echo '\u{1F4A1} Direct git push bypasses automation' && exit 1",
         "git-push": "echo '\u{1F6A8} BLOCKED: Use npm run smart-push instead' && echo '\u{1F4A1} Direct git push bypasses automation' && exit 1"