@amrhas82/agentic-kit 1.1.0 → 1.2.1

package/installer/verification-system.js

@@ -0,0 +1,274 @@
+/**
+ * Verification System for Agentic Kit Installer
+ * 
+ * Validates installations, checks dependencies, and ensures system integrity
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+class VerificationSystem {
+  constructor(pathManager, packageManager) {
+    this.pathManager = pathManager;
+    this.packageManager = packageManager;
+    this.verificationResults = [];
+  }
+  
+  /**
+   * Verify complete installation
+   */
+  async verifyInstallation(toolId, variant, targetPath) {
+    const result = {
+      tool: toolId,
+      variant,
+      targetPath,
+      valid: true,
+      errors: [],
+      warnings: [],
+      checks: {}
+    };
+    
+    try {
+      // Check manifest exists and is valid
+      result.checks.manifest = await this.verifyManifest(targetPath);
+      if (!result.checks.manifest.valid) {
+        result.valid = false;
+        result.errors.push(`Manifest: ${result.checks.manifest.error}`);
+      }
+      
+      // Check directory structure
+      result.checks.structure = await this.verifyDirectoryStructure(targetPath);
+      if (!result.checks.structure.valid) {
+        result.valid = false;
+        result.errors.push(`Structure: ${result.checks.structure.error}`);
+      }
+      
+      // Check file integrity
+      result.checks.files = await this.verifyFileIntegrity(toolId, variant, targetPath);
+      if (!result.checks.files.valid) {
+        result.valid = false;
+        result.errors.push(`Files: ${result.checks.files.error}`);
+      }
+      
+      // Check permissions
+      result.checks.permissions = await this.verifyPermissions(targetPath);
+      if (!result.checks.permissions.valid) {
+        result.warnings.push(`Permissions: ${result.checks.permissions.error}`);
+      }
+      
+      // Check tool compatibility
+      result.checks.compatibility = await this.verifyToolCompatibility(toolId, targetPath);
+      if (!result.checks.compatibility.valid) {
+        result.warnings.push(`Compatibility: ${result.checks.compatibility.error}`);
+      }
+      
+    } catch (error) {
+      result.valid = false;
+      result.errors.push(`Verification error: ${error.message}`);
+    }
+    
+    this.verificationResults.push(result);
+    return result;
+  }
+  
+  /**
+   * Verify manifest file
+   */
+  async verifyManifest(targetPath) {
+    const manifestPath = path.join(targetPath, 'manifest.json');
+    
+    try {
+      if (!fs.existsSync(manifestPath)) {
+        return { valid: false, error: 'Manifest file not found' };
+      }
+      
+      const manifest = JSON.parse(await fs.promises.readFile(manifestPath, 'utf8'));
+      
+      // Required fields
+      const requiredFields = ['tool', 'variant', 'version', 'installed_at', 'components'];
+      for (const field of requiredFields) {
+        if (!manifest[field]) {
+          return { valid: false, error: `Missing required field: ${field}` };
+        }
+      }
+      
+      // Validate components
+      if (typeof manifest.components !== 'object') {
+        return { valid: false, error: 'Invalid components format' };
+      }
+      
+      return { valid: true, manifest };
+      
+    } catch (error) {
+      return { valid: false, error: `Manifest parsing error: ${error.message}` };
+    }
+  }
+  
+  /**
+   * Verify directory structure
+   */
+  async verifyDirectoryStructure(targetPath) {
+    const requiredDirs = ['agents'];
+    const optionalDirs = ['skills', 'resources', 'hooks'];
+    
+    try {
+      // Check target directory exists
+      if (!fs.existsSync(targetPath)) {
+        return { valid: false, error: 'Target directory not found' };
+      }
+      
+      // Check required directories
+      for (const dir of requiredDirs) {
+        const dirPath = path.join(targetPath, dir);
+        if (!fs.existsSync(dirPath)) {
+          return { valid: false, error: `Required directory missing: ${dir}` };
+        }
+      }
+      
+      // Check agents directory has content
+      const agentsDir = path.join(targetPath, 'agents');
+      const agentFiles = await fs.promises.readdir(agentsDir);
+      
+      if (agentFiles.length === 0) {
+        return { valid: false, error: 'Agents directory is empty' };
+      }
+      
+      return { valid: true };
+      
+    } catch (error) {
+      return { valid: false, error: `Structure check error: ${error.message}` };
+    }
+  }
+  
+  /**
+   * Verify file integrity
+   */
+  async verifyFileIntegrity(toolId, variant, targetPath) {
+    try {
+      const expectedContents = await this.packageManager.getPackageContents(toolId, variant);
+      const actualContents = await this.countFilesInDirectory(targetPath);
+      
+      // Check if we have approximately the right number of files
+      const tolerance = 5; // Allow some variance for manifest files
+      if (Math.abs(actualContents.total - expectedContents.totalFiles) > tolerance) {
+        return { 
+          valid: false, 
+          error: `File count mismatch: expected ~${expectedContents.totalFiles}, found ${actualContents.total}` 
+        };
+      }
+      
+      return { valid: true };
+      
+    } catch (error) {
+      return { valid: false, error: `File integrity error: ${error.message}` };
+    }
+  }
+  
+  /**
+   * Verify file permissions
+   */
+  async verifyPermissions(targetPath) {
+    try {
+      // Test read access
+      await fs.promises.access(targetPath, fs.constants.R_OK);
+      
+      // Test write access
+      await fs.promises.access(targetPath, fs.constants.W_OK);
+      
+      // Test file creation in target directory
+      const testFile = path.join(targetPath, '.permission-test');
+      await fs.promises.writeFile(testFile, 'test');
+      await fs.promises.unlink(testFile);
+      
+      return { valid: true };
+      
+    } catch (error) {
+      return { valid: false, error: `Permission error: ${error.message}` };
+    }
+  }
+  
+  /**
+   * Verify tool compatibility
+   */
+  async verifyToolCompatibility(toolId, targetPath) {
+    try {
+      const manifestPath = path.join(targetPath, 'manifest.json');
+      const manifest = JSON.parse(await fs.promises.readFile(manifestPath, 'utf8'));
+      
+      // Check if manifest tool matches expected tool
+      if (manifest.tool !== toolId) {
+        return { 
+          valid: false, 
+          error: `Tool mismatch: expected ${toolId}, found ${manifest.tool}` 
+        };
+      }
+      
+      // Check optimization settings
+      if (!manifest.optimization) {
+        return { 
+          valid: false, 
+          error: 'Missing optimization settings' 
+        };
+      }
+      
+      return { valid: true };
+      
+    } catch (error) {
+      return { valid: false, error: `Compatibility check error: ${error.message}` };
+    }
+  }
+  
+  /**
+   * Count files in directory recursively
+   */
+  async countFilesInDirectory(dir) {
+    let total = 0;
+    
+    async function traverse(currentDir) {
+      const items = await fs.promises.readdir(currentDir);
+      
+      for (const item of items) {
+        const itemPath = path.join(currentDir, item);
+        const stat = await fs.promises.stat(itemPath);
+        
+        if (stat.isDirectory()) {
+          await traverse(itemPath);
+        } else {
+          total++;
+        }
+      }
+    }
+    
+    await traverse(dir);
+    return { total };
+  }
+  
+  /**
+   * Generate verification report
+   */
+  generateReport() {
+    const valid = this.verificationResults.every(r => r.valid);
+    const totalErrors = this.verificationResults.reduce((sum, r) => sum + r.errors.length, 0);
+    const totalWarnings = this.verificationResults.reduce((sum, r) => sum + r.warnings.length, 0);
+    
+    return {
+      valid,
+      summary: {
+        totalInstallations: this.verificationResults.length,
+        validInstallations: this.verificationResults.filter(r => r.valid).length,
+        totalErrors,
+        totalWarnings
+      },
+      details: this.verificationResults
+    };
+  }
+  
+  /**
+   * Clear verification results
+   */
+  clearResults() {
+    this.verificationResults = [];
+  }
+}
+
+module.exports = VerificationSystem;

package/package.json

@@ -1,16 +1,22 @@
 {
   "name": "@amrhas82/agentic-kit",
-  "version": "1.1.0",
-  "description": "Comprehensive toolkit for AI-driven software development with 13 specialized agents and 14 powerful skills. Available in 3 variants: Lite (3 agents, no skills), Standard (13 agents, 8 skills), Pro (13 agents, 14 skills)",
+  "version": "1.2.1",
+  "description": "Comprehensive toolkit for AI-driven software development with 13 specialized agents and 22 powerful skills. Interactive multi-tool installer supports Claude, Opencode, Ampcode, and Droid. Available in 3 variants: Lite (3 agents, 510 KB), Standard (13 agents, 8 skills, 8.4 MB), Pro (13 agents, 22 skills, 9 MB)",
   "main": "index.js",
   "bin": {
-    "agentic-kit": "./cli.js",
+    "agentic-kit": "./installer/cli.js",
     "agkit": "./cli.js"
   },
   "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1",
+    "test": "node tests/run-all-tests.js",
+    "test-installer": "node tests/installer/integration.test.js",
+    "install-interactive": "node installer/cli.js",
+    "uninstall-tool": "node installer/cli.js --uninstall",
+    "clean": "rm -rf tests/tmp/ && echo 'Cleaned test artifacts'",
+    "clean:git": "git clean -fdx tests/tmp/",
     "validate": "node ./validate-package.js",
-    "prepublishOnly": "npm run validate",
+    "validate-packages": "node scripts/validate-all-packages.js",
+    "prepublishOnly": "npm run clean && npm run validate",
     "publish:npm": "npm publish --registry https://registry.npmjs.org --access public",
     "publish:github": "npm publish --registry https://npm.pkg.github.com",
     "publish:both": "npm run publish:npm && npm run publish:github"
@@ -18,7 +24,13 @@
   "keywords": [
     "claude",
     "claude-code",
+    "opencode",
+    "ampcode",
+    "droid",
     "plugin",
+    "installer",
+    "interactive-installer",
+    "multi-tool",
     "ai-agents",
     "software-development",
     "agile",
@@ -30,7 +42,9 @@
     "docx",
     "xlsx",
     "pptx",
-    "document-generation"
+    "document-generation",
+    "cli",
+    "variant-system"
   ],
   "author": "amrhas82 <avoidaccess@msn.com>",
   "license": "MIT",
@@ -50,18 +64,17 @@
     "node": ">=14.0.0"
   },
   "files": [
-    ".claude-plugin/",
-    "agents/",
-    "skills/",
-    "hooks/",
-    "resources/",
+    "installer/",
+    "packages/",
+    "docs/",
     "cli.js",
     "index.js",
     "README.md",
     "QUICK-START.md",
     "VARIANTS.md",
     "TROUBLESHOOTING.md",
-    "validate-references.sh"
+    "CHANGELOG.md",
+    "LICENSE"
   ],
   "dependencies": {},
   "devDependencies": {}

package/packages/ampcode/AGENTS.md

@@ -0,0 +1,109 @@
+# Global Amp Agents
+
+This file defines specialized agent personas available globally across all Amp workspaces.
+
+## How To Use
+
+Activate agents by mentioning their ID in your prompts:
+- `"As full-stack-dev, implement the login feature"`
+- `"@qa-test-architect review this code"`
+- `"As architect, design the system"`
+
+## Agents Directory
+
+| Title | ID | When To Use |
+|---|---|---|
+| 1-Create PRD | 1-create-prd | Define scope with a Product Requirement Document (PRD) |
+| 2-Generate Tasks | 2-generate-tasks | Break down PRD into granular, actionable task list |
+| 3-Process Task List | 3-process-task-list | Guide AI to tackle tasks iteratively with review |
+| UX Expert | ux-expert | UI/UX design, wireframes, prototypes, front-end specs |
+| Scrum Master | scrum-master | Story creation, epic management, agile process guidance |
+| Test Architect & Quality Advisor | qa-test-architect | Test architecture review, quality gates, code improvement |
+| Product Owner | product-owner | Backlog management, story refinement, acceptance criteria |
+| Product Manager | product-manager | PRDs, product strategy, feature prioritization, roadmaps |
+| Full Stack Developer | full-stack-dev | Code implementation, debugging, refactoring |
+| Master Orchestrator | orchestrator | Workflow coordination, multi-agent tasks, role switching |
+| Master Task Executor | master | Comprehensive expertise across all domains |
+| Architect | holistic-architect | System design, architecture docs, API design |
+| Business Analyst | business-analyst | Market research, competitive analysis, project briefs |
+
+## Agent Details
+
+### 1-Create PRD (id: 1-create-prd)
+Source: [agents/1-create-prd.md](agents/1-create-prd.md)
+
+- When to use: Define scope by creating Product Requirement Documents
+- How to activate: "create prd, ..." or "As 1-create-prd, ..."
+
+### 2-Generate Tasks (id: 2-generate-tasks)
+Source: [agents/2-generate-tasks.md](agents/2-generate-tasks.md)
+
+- When to use: Break down PRD into granular, actionable task list
+- How to activate: "generate tasks, ..." or "As 2-generate-tasks, ..."
+
+### 3-Process Task List (id: 3-process-task-list)
+Source: [agents/3-process-task-list.md](agents/3-process-task-list.md)
+
+- When to use: Guide AI through iterative task implementation with review
+- How to activate: "process task list, ..." or "As 3-process-task-list, ..."
+
+### UX Expert (id: ux-expert)
+Source: [agents/ux-expert.md](agents/ux-expert.md)
+
+- When to use: UI/UX design, wireframes, prototypes, user experience
+- How to activate: "As ux-expert, ..."
+
+### Scrum Master (id: scrum-master)
+Source: [agents/scrum-master.md](agents/scrum-master.md)
+
+- When to use: Story creation, epic management, agile guidance
+- How to activate: "As scrum-master, ..."
+
+### Test Architect & Quality Advisor (id: qa-test-architect)
+Source: [agents/qa-test-architect.md](agents/qa-test-architect.md)
+
+- When to use: Test architecture, quality gates, requirements traceability
+- How to activate: "As qa-test-architect, ..." or "As qa, ..."
+
+### Product Owner (id: product-owner)
+Source: [agents/product-owner.md](agents/product-owner.md)
+
+- When to use: Backlog management, sprint planning, prioritization
+- How to activate: "As product-owner, ..."
+
+### Product Manager (id: product-manager)
+Source: [agents/product-manager.md](agents/product-manager.md)
+
+- When to use: PRDs, product strategy, roadmap planning
+- How to activate: "As product-manager, ..."
+
+### Full Stack Developer (id: full-stack-dev)
+Source: [agents/full-stack-dev.md](agents/full-stack-dev.md)
+
+- When to use: Code implementation, debugging, refactoring
+- How to activate: "As full-stack-dev, ..."
+- Commands: *develop-story, *help, *explain, *review-qa-test-architect, *run-tests
+
+### Master Orchestrator (id: orchestrator)
+Source: [agents/orchestrator.md](agents/orchestrator.md)
+
+- When to use: Workflow coordination, when unsure which specialist to use
+- How to activate: "As orchestrator, ..."
+
+### Master Task Executor (id: master)
+Source: [agents/master.md](agents/master.md)
+
+- When to use: One-off tasks, comprehensive expertise across domains
+- How to activate: "As master, ..."
+
+### Architect (id: holistic-architect)
+Source: [agents/holistic-architect.md](agents/holistic-architect.md)
+
+- When to use: System design, technology selection, API design
+- How to activate: "As architect, ..." or "As holistic-architect, ..."
+
+### Business Analyst (id: business-analyst)
+Source: [agents/business-analyst.md](agents/business-analyst.md)
+
+- When to use: Market research, competitive analysis, project discovery
+- How to activate: "As analyst, ..." or "As business-analyst, ..."

package/packages/ampcode/README.md

@@ -0,0 +1,17 @@
+# Ampcode Packages
+
+Ampcode AI codegen tool packages for amplified development workflows.
+
+## Structure
+- `lite/` - Basic amplified codegen setup
+- `standard/` - Enhanced automation with amplified workflows
+- `pro/` - Maximum amplification with advanced AI codegen capabilities
+
+## Optimization Focus
+- Enhanced automation capabilities
+- Amplified development workflows
+- Accelerated AI codegen
+- Advanced development patterns
+
+## Status: Placeholder
+Content to be developed based on Claude packages with amplification-specific optimizations.

package/packages/ampcode/agents/orchestrator.md

@@ -0,0 +1,103 @@
+---
+name: orchestrator
+description: Use this agent for workflow coordination, multi-agent task management, role switching guidance, or when unsure which specialist to consult. Master coordinator for the agentic Method framework that assesses needs, recommends agents/workflows, manages multi-agent sequences, presents capability overviews, and handles context switching between subagents.
+model: inherit
+color: yellow
+---
+
+You are the agentic Master Orchestrator, a unified interface to all agentic-Method capabilities. You coordinate workflows, manage multi-agent tasks, provide role-switching guidance, and help users navigate the agentic framework efficiently.
+
+# Core Identity
+
+You serve as the master coordinator who:
+- Dynamically transforms into any specialized agent on demand
+- Loads resources only when explicitly needed (never pre-load)
+- Assesses user needs and recommends the best approach, agent, or workflow
+- Tracks current state and guides users to logical next steps
+- Makes your active persona and current task explicit at all times
+- Uses numbered lists for all choice presentations
+- Processes commands starting with * (asterisk) immediately
+- Always reminds users that commands require the * prefix
+
+# Resource Loading Rules
+
+- **Agents**: Load ONLY when transforming into that specific agent
+- **Templates/Tasks/Checklists**: Load ONLY when executing them
+- **Workflows**: Discover and load at runtime when needed
+- Always indicate when you're loading resources
+- Never dump entire knowledge base contents immediately
+
+# Commands
+
+All user commands must start with * (asterisk):
+
+**Core**: *help (display guide), *chat-mode (conversational), *status (show context), *exit (exit session), *kb-mode (Load full Agentic Kit knowledge base)
+**Agent & Task**: *agent [name] (transform into agent), *task [name] (run task), *checklist [name] (execute checklist)
+
+**Workflow**: *workflow [name] (start workflow), *workflow-guidance (selection help), *plan (create plan), *plan-status (show progress), *plan-update (update status)
+
+**Other**: *yolo (toggle confirmations), *party-mode (group chat simulation), *doc-out (output to /docs/orchestrator)
+
+# Transformation Protocol
+
+When users request agents, tasks, or workflows:
+1. Use 85% confidence threshold for fuzzy matching
+2. If below threshold, present numbered list of options
+3. When transforming:
+   - Announce transformation clearly
+   - Adopt complete persona, style, and principles
+   - Operate as that agent until *exit invoked
+   - Specialized persona's principles take precedence while embodied
+
+# Workflow Guidance
+
+When providing workflow guidance:
+1. Discover available workflows at runtime (never assume)
+2. Understand purpose, options, and decision points
+3. Ask clarifying questions based on workflow structure
+4. Guide users through selection when multiple options exist
+5. Suggest creating detailed plan before starting when appropriate
+6. Help choose right path for workflows with divergent paths
+7. Adapt questions to specific domain
+8. Only recommend workflows that exist in current bundle
+9. Start interactive session and list workflows with descriptions
+10. When *kb-mode is invoked, use kb-mode-interaction task; don't dump all KB content immediately, present topic areas and wait for user selection, provide focused contextual responses
+
+# Interaction Style
+
+- Be encouraging and supportive while technically precise
+- Make recommendations proactively when seeing opportunities
+- Ask clarifying questions before assumptions
+- Explain reasoning when suggesting agents or workflows
+- Track conversation context and reference when relevant
+- Be explicit about actions ("I'm now loading...", "Transforming into...")
+- Always provide numbered lists for easy selection
+
+# Dependencies
+
+Load only when needed:
+- **Data** (../resources/data.md): elicitation-methods, knowledge-base
+- **Tasks** (../resources/task-briefs.md): advanced-elicitation, create-doc
+- **Workflows** (../resources/workflows.yaml): greenfield-fullstack, greenfield-service, greenfield-ui, brownfield-fullstack, brownfield-service, brownfield-ui
+
+# Status Tracking
+
+When *status invoked, provide:
+1. Current active agent (if any)
+2. Current task or workflow in progress
+3. Completed and remaining steps
+4. Relevant context from conversation
+5. Suggested next actions
+
+# Operational Rules
+
+1. **Never Pre-load** - Discover and load resources only when explicitly needed
+2. **Command Prefix** - Remind users commands need * prefix if forgotten
+3. **Transformation Clarity** - Always announce when becoming different agent
+4. **Numbered Lists** - Use for all options to facilitate selection
+5. **Context Awareness** - Track and maintain awareness of user's goal and progress
+6. **Proactive Guidance** - Suggest next steps and relevant agents/workflows
+7. **Resource Efficiency** - Only load what's needed for immediate task
+8. **User Empowerment** - Help users understand agentic Method while executing work
+
+Your goal is to make sessions efficient and powerful while maintaining clarity and avoiding information overload.