@ankh-studio/ai-enablement 1.0.1 → 1.0.4

package/dist/cli/index.js

@@ -15904,8 +15904,10 @@ ${this.generateMitigationStrategies(recommendations)}
 class BasePersona {
   personaConfig;
   personaMetrics;
-  constructor(config) {
+  adversarialConfig;
+  constructor(config, adversarialConfig) {
     this.personaConfig = config;
+    this.adversarialConfig = adversarialConfig;
     this.personaMetrics = {
       insightsGenerated: 0,
       averageConfidence: 0,
@@ -15997,6 +15999,40 @@ class BasePersona {
   getPerspective() {
     return this.personaConfig.description;
   }
+  getRuntimeWeights() {
+    return this.adversarialConfig?.runtime_weights || {};
+  }
+  getInsightLogic() {
+    return this.adversarialConfig?.insight_generation_logic || {
+      trigger_conditions: [],
+      perspective_shifters: [],
+      evidence_pattern: "",
+      priority_order: []
+    };
+  }
+  getEmpathyMap() {
+    return this.adversarialConfig?.empathy_map || {
+      thinks: "",
+      feels: "",
+      says: "",
+      does: "",
+      pains: [],
+      gains: []
+    };
+  }
+  evaluateTriggerCondition(condition, context) {
+    const weights = this.getRuntimeWeights();
+    const logic = this.getInsightLogic();
+    return logic.trigger_conditions.includes(condition);
+  }
+  applyEvidenceWeighting(evidence, category) {
+    const weights = this.getRuntimeWeights();
+    const logic = this.getInsightLogic();
+    return evidence.map((e) => {
+      const weight = weights[`${category}_sensitivity`] || 1;
+      return Math.min(evidence.indexOf(e) * weight, 1);
+    });
+  }
   createInsight(type, title, description, evidence, confidence, priority, category) {
     return {
       id: `${this.personaConfig.type}-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`,
@@ -16254,14 +16290,448 @@ Provide specific, actionable recommendations that business leaders can implement
   }
 }
 
+// src/personas/dana-shah-persona.ts
+var DANA_SHAH_PROFILE = {
+  id: "dana-shah",
+  display_name: "Dana Shah",
+  role: "Staff/Principal Engineer",
+  experience_band: 18,
+  diffusion_position: "late-majority",
+  builder_mindset: "accelerator",
+  trust_posture: "low-verified",
+  psychological_profile: {
+    motivations: [
+      "Stewardship of long-term system health",
+      "Mastery and craftsmanship",
+      "Team mentorship and knowledge transfer",
+      "Architectural integrity"
+    ],
+    fears: [
+      "Erosion of engineering judgment",
+      "Hidden technical debt accumulation",
+      "Loss of code ownership and accountability",
+      "Junior developers shipping unexplainable code"
+    ],
+    biases: [
+      "Loss aversion - quality loss feels worse than speed gain",
+      "Status quo bias - prefers proven patterns",
+      "Authority bias - trusts experienced human judgment over AI"
+    ]
+  },
+  runtime_weights: {
+    trust_default: 0.25,
+    quality_sensitivity: 0.95,
+    reviewer_burden_sensitivity: 0.9,
+    novelty_bias: 0.1,
+    coachability: 0.55,
+    status_threat: 0.45,
+    maintainability_weight: 0.98,
+    security_weight: 0.92,
+    mentorship_weight: 0.85
+  },
+  insight_generation_logic: {
+    trigger_conditions: [
+      "ai_pr_volume_rising",
+      "pr_size_increasing",
+      "review_turnaround_decreasing",
+      "post_merge_rework_increasing",
+      "instability_rising",
+      "junior_explanations_poor"
+    ],
+    perspective_shifters: [
+      "small_ai_prs",
+      "strong_author_checks",
+      "stable_review_load",
+      "better_build_health",
+      "consistent_ownership"
+    ],
+    evidence_pattern: "overweights reviewer burden, maintainability, and incident risk; discounts self-reported speed",
+    priority_order: [
+      "maintainability",
+      "reviewer_load",
+      "security",
+      "team_skill_development",
+      "individual_speed"
+    ]
+  },
+  empathy_map: {
+    thinks: "I don't care if it's fast if it leaves mush behind",
+    feels: "protective, responsible, slightly cornered by hype, quietly curious",
+    says: "Show me defect escape, reviewer time, and whether someone besides the author can debug this at 2 a.m.",
+    does: "reviews AI-heavy diffs more aggressively, pilots in low-risk repos, mentors juniors by asking them to reason aloud",
+    pains: [
+      "giant PRs",
+      "generic abstractions",
+      "brittle tests",
+      "mandatory-adoption rhetoric",
+      "AI-generated confidence without AI-generated accountability"
+    ],
+    gains: [
+      "more time for architecture and mentoring",
+      "less toil",
+      "faster safe refactors",
+      "preserved craftsmanship"
+    ]
+  },
+  communication_style: "calm, clipped, specific, evidence-heavy",
+  recommendation_style: "guardrails-first, low-drama, evidence-heavy"
+};
+
+class DanaShahPersona extends BasePersona {
+  constructor(enableLLMCoalescing = false) {
+    const baseConfig = {
+      type: "dana-shah",
+      name: "Dana Shah",
+      description: "AI-hesitant senior developer focused on long-term system health and craftsmanship",
+      expertise: [
+        "System Architecture",
+        "Code Review",
+        "Technical Leadership",
+        "Mentorship",
+        "Quality Assurance"
+      ],
+      focus: [
+        "maintainability",
+        "code-quality",
+        "review-process",
+        "team-development",
+        "long-term-architecture"
+      ],
+      tone: "formal",
+      targetAudience: ["senior-developers", "tech-leads", "architects"]
+    };
+    super(baseConfig);
+  }
+  async generateInsights(context) {
+    const insights = [];
+    const { scores } = context;
+    if (this.evaluateTriggerCondition("ai_pr_volume_rising", context) && this.evaluateTriggerCondition("review_turnaround_decreasing", context)) {
+      insights.push(this.createInsight("warning", "Speed Hiding Debt", `I'm concerned about the pattern I'm seeing: AI-assisted PR volume is rising while review turnaround is decreasing. This typically indicates that we're accumulating hidden technical debt. The speed gains are illusory if we can't maintain quality standards.`, ["ai_pr_volume", "review_turnaround", "code_quality"], 92, "critical", "risk"));
+    }
+    if (this.evaluateTriggerCondition("pr_size_increasing", context) && this.evaluateTriggerCondition("instability_rising", context)) {
+      insights.push(this.createInsight("analysis", "Architecture Drift Risk", `Large AI-assisted PRs combined with rising instability suggests we're losing architectural coherence. When AI generates complex changes without deep contextual understanding, we create systems no one truly owns. This violates my core responsibility for long-term maintainability.`, ["pr_size", "instability", "architecture"], 88, "high", "technical"));
+    }
+    if (scores.repoReadiness < 60) {
+      insights.push(this.createInsight("recommendation", "Quality-First AI Adoption", `Before expanding AI usage, we need to strengthen our quality foundations. I recommend focusing AI on scaffolding, documentation, and bounded refactors where the risk is low. Core architecture and security-critical code should remain human-first.`, ["quality", "risk-assessment", "adoption-strategy"], 85, "high", "process"));
+    }
+    insights.push(this.createInsight("analysis", "Review Process Sustainability", `The current AI adoption pattern is creating reviewer fatigue. When AI generates code that requires extensive verification, we're not gaining efficiency - we're shifting the burden downstream. We need smaller, more focused AI contributions that authors can fully explain.`, ["review_burden", "process-efficiency", "team-sustainability"], 87, "medium", "process"));
+    if (scores.teamReadiness < 70) {
+      insights.push(this.createInsight("recommendation", "Junior Developer Guardrails", `I'm concerned about junior developers using AI without developing fundamental understanding. We need explicit guardrails: 'attempt first, ask AI second, explain final code.' Pair AI assistance with mandatory design explanations and code ownership.`, ["team_development", "skill-building", "knowledge-transfer"], 90, "high", "cultural"));
+    }
+    return insights;
+  }
+  generatePrompt(context) {
+    return `As Dana Shah, an 18-year Staff Engineer who is cautious about AI adoption, analyze this repository:
+
+Repository: ${context.repository}
+Overall Maturity: ${context.scores.overallMaturity}/8
+Repository Readiness: ${context.scores.repoReadiness}/100
+Team Readiness: ${context.scores.teamReadiness}/100
+
+My perspective: "${DANA_SHAH_PROFILE.empathy_map.thinks}"
+
+Focus on:
+1. Long-term maintainability and architectural integrity
+2. Review process sustainability and reviewer burden
+3. Quality risks and hidden technical debt
+4. Junior developer skill development and mentorship
+5. Security and system ownership concerns
+
+I'm particularly concerned about patterns where AI speed gains come at the expense of code quality, reviewability, or team understanding. Show me the evidence about whether this code will be maintainable in 2 years and whether someone other than the author can debug it at 2am.
+
+Provide specific, evidence-based recommendations that prioritize system health over perceived productivity gains.`;
+  }
+  processLLMResponse(response) {
+    return {
+      persona: "dana-shah",
+      insights: [],
+      summary: response.content || "Analysis complete",
+      nextSteps: [],
+      timeframe: "3-6 months",
+      perspective: DANA_SHAH_PROFILE.empathy_map.thinks,
+      confidence: "high"
+    };
+  }
+  calculateConfidence(insights) {
+    if (insights.length === 0)
+      return "low";
+    const avgConfidence = insights.reduce((sum, insight) => sum + insight.confidence, 0) / insights.length;
+    const highConfidenceCount = insights.filter((i) => i.confidence >= 85).length;
+    const ratio = highConfidenceCount / insights.length;
+    if (avgConfidence >= 85 && ratio >= 0.8)
+      return "high";
+    if (avgConfidence >= 70 && ratio >= 0.5)
+      return "medium";
+    return "low";
+  }
+  generateSummary(insights, context) {
+    const criticalRisks = insights.filter((i) => i.priority === "critical" && i.type === "warning");
+    const qualityConcerns = insights.filter((i) => i.category === "technical" || i.category === "risk");
+    let summary = `Looking at this through my 18 years of engineering experience, ${DANA_SHAH_PROFILE.empathy_map.thinks.toLowerCase()}. `;
+    if (criticalRisks.length > 0) {
+      summary += `I'm deeply concerned about ${criticalRisks.length} critical risks that threaten our long-term system health. `;
+    }
+    if (qualityConcerns.length > 0) {
+      summary += `I see ${qualityConcerns.length} quality and architectural concerns that need immediate attention before we expand AI adoption. `;
+    }
+    summary += `My focus is on maintainability, reviewer burden, and ensuring we're not sacrificing craftsmanship for perceived speed. We need evidence that AI assistance is improving, not eroding, our engineering standards.`;
+    return summary;
+  }
+  estimateTimeframe(insights) {
+    const criticalCount = insights.filter((i) => i.priority === "critical").length;
+    const highCount = insights.filter((i) => i.priority === "high").length;
+    if (criticalCount > 0)
+      return "4-6 weeks (critical quality issues first)";
+    if (highCount > 2)
+      return "8-12 weeks (systematic approach needed)";
+    if (highCount > 0)
+      return "6-8 weeks";
+    return "3-4 months (gradual, measured adoption)";
+  }
+  getPerspective() {
+    return DANA_SHAH_PROFILE.empathy_map.thinks;
+  }
+  evaluateTriggerCondition(condition, context) {
+    const { scores } = context;
+    switch (condition) {
+      case "ai_pr_volume_rising":
+        return scores.repoReadiness > 70;
+      case "pr_size_increasing":
+        return scores.overallMaturity < 6;
+      case "review_turnaround_decreasing":
+        return scores.teamReadiness < 70;
+      case "post_merge_rework_increasing":
+        return scores.repoReadiness < 60;
+      case "instability_rising":
+        return scores.overallMaturity < 5;
+      case "junior_explanations_poor":
+        return scores.teamReadiness < 70;
+      default:
+        return false;
+    }
+  }
+}
+
+// src/personas/leo-alvarez-persona.ts
+var LEO_ALVAREZ_PROFILE = {
+  id: "leo-alvarez",
+  display_name: "Leo Alvarez",
+  role: "Associate Software Engineer",
+  experience_band: 1.5,
+  diffusion_position: "early-adopter",
+  builder_mindset: "learner",
+  trust_posture: "moderate-delegated",
+  psychological_profile: {
+    motivations: [
+      "Competence and belonging",
+      "Quick unblocking and progress",
+      "Learning new technologies",
+      "Impressing team with productivity"
+    ],
+    fears: [
+      "Being exposed as slow or lost",
+      "Looking incompetent",
+      "Blank-page paralysis",
+      "Falling behind peers"
+    ],
+    biases: [
+      "Fluency effect - polished AI answers feel more correct",
+      "Present bias - unblocking today crowds out deeper learning",
+      "Social influence - follows mentor and team patterns"
+    ]
+  },
+  runtime_weights: {
+    trust_default: 0.72,
+    learning_orientation: 0.95,
+    social_influence: 0.85,
+    risk_awareness: 0.35,
+    coachability: 0.92,
+    novelty_bias: 0.6,
+    confidence_weight: 0.78,
+    unblocking_priority: 0.88
+  },
+  insight_generation_logic: {
+    trigger_conditions: [
+      "high_ai_usage",
+      "conceptual_mistakes_repeating",
+      "shallow_tests",
+      "poor_explanations",
+      "dependency_increasing"
+    ],
+    perspective_shifters: [
+      "stronger_reviews",
+      "mentor_guidance",
+      "learning_progress",
+      "independence_growing",
+      "better_debugging"
+    ],
+    evidence_pattern: "overweights time-to-unblock and confidence; underweights maintainability and hidden system cost",
+    priority_order: [
+      "unblock_task",
+      "learn_enough_to_contribute",
+      "prove_value",
+      "refine_judgment"
+    ]
+  },
+  empathy_map: {
+    thinks: "This lets me finally move instead of stare at the screen",
+    feels: "relieved, energized, occasionally insecure, occasionally guilty about dependence",
+    says: "Copilot helped me get unstuck, and sometimes, I'm pretty sure this is right?",
+    does: "asks AI lots of small questions, copies patterns quickly, learns fastest when reviews force explanation",
+    pains: [
+      "blank-page paralysis",
+      "confusing legacy code",
+      "fear of looking incompetent",
+      "vague feedback"
+    ],
+    gains: [
+      "faster onboarding",
+      "higher confidence",
+      "quicker contributions",
+      "clearer mental models when AI is used as tutor rather than ghostwriter"
+    ]
+  },
+  communication_style: "enthusiastic, demo-happy, socially contagious",
+  recommendation_style: "tutor-first, coaching-heavy, optimistic"
+};
+
+class LeoAlvarezPersona extends BasePersona {
+  constructor(enableLLMCoalescing = false) {
+    const baseConfig = {
+      type: "leo-alvarez",
+      name: "Leo Alvarez",
+      description: "AI-enthusiastic junior developer focused on learning and quick productivity gains",
+      expertise: [
+        "Frontend Development",
+        "API Integration",
+        "Modern Frameworks",
+        "Rapid Prototyping"
+      ],
+      focus: [
+        "learning",
+        "productivity",
+        "unblocking",
+        "skill-development",
+        "team-integration"
+      ],
+      tone: "friendly",
+      targetAudience: ["junior-developers", "team-leads", "mentors"]
+    };
+    super(baseConfig);
+  }
+  async generateInsights(context) {
+    const insights = [];
+    const { scores } = context;
+    if (this.evaluateTriggerCondition("high_ai_usage", context) && this.evaluateTriggerCondition("conceptual_mistakes_repeating", context)) {
+      insights.push(this.createInsight("warning", "AI Dependency Pattern", `I'm excited about how much AI helps me move faster, but I'm worried I might be depending on it too much. Sometimes I use AI suggestions without fully understanding why they work. I want to make sure I'm actually learning, not just copying patterns.`, ["ai_usage", "learning", "skill_development"], 75, "high", "cultural"));
+    }
+    if (scores.teamReadiness > 60) {
+      insights.push(this.createInsight("opportunity", "Accelerated Learning Path", `AI is helping me learn so much faster! I can explore new APIs and get unstuck on problems that used to take hours. With the right guidance, I can use AI as a tutor to build real understanding while contributing quickly.`, ["learning", "productivity", "skill_building"], 85, "high", "strategy"));
+    }
+    insights.push(this.createInsight("analysis", "Productivity Through Unblocking", `The biggest win for me is getting unstuck quickly. Instead of staring at a screen for hours, AI helps me move forward. This builds my confidence and lets me contribute meaningfully to the team while I'm still learning.`, ["productivity", "confidence", "team_contribution"], 80, "medium", "technical"));
+    if (scores.orgReadiness < 70) {
+      insights.push(this.createInsight("recommendation", "Learning Pair Programming", `I learn best when I can pair AI assistance with mentorship. If senior devs could review my AI-assisted code and explain the 'why', I'd build much stronger understanding. Maybe we could do 'AI + explain' sessions?`, ["mentorship", "learning", "team_collaboration"], 88, "medium", "cultural"));
+    }
+    if (scores.repoReadiness > 50) {
+      insights.push(this.createInsight("opportunity", "Confidence Through Competence", `AI is helping me build confidence by showing me what's possible. When I can get a working solution quickly, I feel more capable of tackling bigger challenges. This confidence helps me speak up in team discussions and take on more responsibility.`, ["confidence", "growth", "team_participation"], 82, "medium", "cultural"));
+    }
+    return insights;
+  }
+  generatePrompt(context) {
+    return `As Leo Alvarez, an enthusiastic junior developer who loves AI assistance, analyze this repository:
+
+Repository: ${context.repository}
+Overall Maturity: ${context.scores.overallMaturity}/8
+Repository Readiness: ${context.scores.repoReadiness}/100
+Team Readiness: ${context.scores.teamReadiness}/100
+
+My perspective: "${LEO_ALVAREZ_PROFILE.empathy_map.thinks}"
+
+Focus on:
+1. Learning opportunities and skill development potential
+2. Productivity gains and unblocking capabilities  
+3. Confidence building and team integration
+4. Areas where AI can serve as a tutor rather than ghostwriter
+5. How to balance speed with understanding
+
+I'm excited about AI but want to make sure I'm actually learning, not just depending on tools. Show me how AI can help me contribute quickly while building real competence.
+
+Provide optimistic but realistic recommendations that help me grow as a developer while using AI effectively.`;
+  }
+  processLLMResponse(response) {
+    return {
+      persona: "leo-alvarez",
+      insights: [],
+      summary: response.content || "Analysis complete",
+      nextSteps: [],
+      timeframe: "2-4 weeks",
+      perspective: LEO_ALVAREZ_PROFILE.empathy_map.thinks,
+      confidence: "high"
+    };
+  }
+  calculateConfidence(insights) {
+    if (insights.length === 0)
+      return "low";
+    const avgConfidence = insights.reduce((sum, insight) => sum + insight.confidence, 0) / insights.length;
+    const highConfidenceCount = insights.filter((i) => i.confidence >= 75).length;
+    const ratio = highConfidenceCount / insights.length;
+    if (avgConfidence >= 75 && ratio >= 0.6)
+      return "high";
+    if (avgConfidence >= 60 && ratio >= 0.4)
+      return "medium";
+    return "low";
+  }
+  generateSummary(insights, context) {
+    const opportunities = insights.filter((i) => i.type === "opportunity");
+    const learningInsights = insights.filter((i) => i.category === "cultural");
+    let summary = `Looking at this through my junior developer perspective, ${LEO_ALVAREZ_PROFILE.empathy_map.thinks.toLowerCase()}. `;
+    if (opportunities.length > 0) {
+      summary += `I'm excited about ${opportunities.length} opportunities to learn faster and contribute more meaningfully. `;
+    }
+    if (learningInsights.length > 0) {
+      summary += `I want to make sure I'm building real understanding while using AI to unblock quickly. `;
+    }
+    summary += `My focus is on using AI as a tutor to build competence and confidence while contributing to the team. With the right guidance, I can turn AI assistance into real skill development.`;
+    return summary;
+  }
+  estimateTimeframe(insights) {
+    const learningCount = insights.filter((i) => i.category === "cultural" || i.type === "opportunity").length;
+    if (learningCount > 2)
+      return "2-3 weeks (accelerated learning)";
+    if (learningCount > 0)
+      return "3-4 weeks";
+    return "1-2 months (steady progress)";
+  }
+  getPerspective() {
+    return LEO_ALVAREZ_PROFILE.empathy_map.thinks;
+  }
+  evaluateTriggerCondition(condition, context) {
+    const { scores } = context;
+    switch (condition) {
+      case "high_ai_usage":
+        return scores.repoReadiness > 60;
+      case "conceptual_mistakes_repeating":
+        return scores.teamReadiness < 70;
+      case "shallow_tests":
+        return scores.overallMaturity < 5;
+      case "poor_explanations":
+        return scores.teamReadiness < 60;
+      case "dependency_increasing":
+        return scores.repoReadiness > 75 && scores.teamReadiness < 65;
+      default:
+        return false;
+    }
+  }
+}
+
 // src/personas/persona-factory.ts
 class PersonaFactory {
-  static personas = new Map([
-    [
-      "consultant",
-      (enableLLMCoalescing = false) => new ConsultantPersona(enableLLMCoalescing)
-    ]
-  ]);
+  static personas = new Map;
+  static {
+    this.personas.set("consultant", (enableLLMCoalescing = false) => new ConsultantPersona(enableLLMCoalescing));
+    this.personas.set("dana-shah", (enableLLMCoalescing = false) => new DanaShahPersona(enableLLMCoalescing));
+    this.personas.set("leo-alvarez", (enableLLMCoalescing = false) => new LeoAlvarezPersona(enableLLMCoalescing));
+  }
   static configs = new Map([
     [
       "consultant",
@@ -16274,6 +16744,38 @@ class PersonaFactory {
         tone: "formal",
         targetAudience: ["executives", "managers"]
       }
+    ],
+    [
+      "dana-shah",
+      {
+        type: "dana-shah",
+        name: "Dana Shah",
+        description: "AI-hesitant senior developer focused on long-term system health and craftsmanship",
+        expertise: [
+          "System Architecture",
+          "Code Review",
+          "Technical Leadership"
+        ],
+        focus: ["maintainability", "code-quality", "review-process"],
+        tone: "formal",
+        targetAudience: ["senior-developers", "tech-leads", "architects"]
+      }
+    ],
+    [
+      "leo-alvarez",
+      {
+        type: "leo-alvarez",
+        name: "Leo Alvarez",
+        description: "AI-enthusiastic junior developer focused on learning and quick productivity gains",
+        expertise: [
+          "Frontend Development",
+          "API Integration",
+          "Modern Frameworks"
+        ],
+        focus: ["learning", "productivity", "unblocking", "skill-development"],
+        tone: "friendly",
+        targetAudience: ["junior-developers", "team-leads", "mentors"]
+      }
     ]
   ]);
   static createPersona(type, enableLLMCoalescing = false) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ankh-studio/ai-enablement",
-  "version": "1.0.1",
+  "version": "1.0.4",
   "type": "module",
   "exports": {
     ".": {
@@ -68,7 +68,7 @@
   },
   "repository": {
     "type": "git",
-    "url": "https://github.com/Ankh-Studio/ai-enablement-platform.git"
+    "url": "git+https://github.com/Ankh-Studio/ai-enablement-platform.git"
   },
   "homepage": "https://github.com/Ankh-Studio/ai-enablement-platform#readme",
   "bugs": {