liteagents 2.4.0

package/installer/report-template.js

@@ -0,0 +1,298 @@
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+/**
+ * Report Template Generator
+ *
+ * Generates detailed installation reports with summary and per-tool details.
+ * Reports are saved to ~/.agentflow-install.log after each installation.
+ */
+class ReportTemplate {
+  constructor() {
+    this.reportPath = path.join(os.homedir(), '.agentflow-install.log');
+  }
+
+  /**
+   * Generate a comprehensive installation report
+   *
+   * @param {Object} installationData - Complete installation data
+   * @param {string} installationData.variant - Selected variant (lite, standard, pro)
+   * @param {Array} installationData.tools - Array of tool installation objects
+   * @param {number} installationData.startTime - Installation start timestamp (ms)
+   * @param {number} installationData.endTime - Installation end timestamp (ms)
+   * @param {boolean} installationData.success - Overall installation success status
+   * @param {Array} installationData.errors - Array of error messages
+   * @param {Array} installationData.warnings - Array of warning messages
+   * @returns {string} Formatted report text
+   */
+  generateReport(installationData) {
+    const {
+      variant,
+      tools = [],
+      startTime,
+      endTime,
+      success,
+      errors = [],
+      warnings = []
+    } = installationData;
+
+    const duration = this._formatDuration(endTime - startTime);
+    const totalFiles = tools.reduce((sum, tool) => sum + (tool.filesInstalled || 0), 0);
+    const totalSize = tools.reduce((sum, tool) => sum + (tool.sizeBytes || 0), 0);
+    const formattedSize = this._formatSize(totalSize);
+
+    let report = '';
+
+    // Header
+    report += this._generateHeader();
+
+    // Summary Section
+    report += this._generateSummary({
+      success,
+      variant,
+      toolCount: tools.length,
+      totalFiles,
+      totalSize: formattedSize,
+      duration,
+      errors,
+      warnings
+    });
+
+    // Tool Details Section
+    if (tools.length > 0) {
+      report += this._generateToolDetails(tools);
+    }
+
+    // System Information Section
+    report += this._generateSystemInfo();
+
+    // Errors Section (if any)
+    if (errors.length > 0) {
+      report += this._generateErrorsSection(errors);
+    }
+
+    // Warnings Section (if any)
+    if (warnings.length > 0) {
+      report += this._generateWarningsSection(warnings);
+    }
+
+    // Footer
+    report += this._generateFooter();
+
+    return report;
+  }
+
+  /**
+   * Save report to file
+   *
+   * @param {string} reportContent - Generated report content
+   * @returns {Promise<string>} Path where report was saved
+   */
+  async saveReport(reportContent) {
+    try {
+      await fs.promises.writeFile(this.reportPath, reportContent, 'utf8');
+      return this.reportPath;
+    } catch (error) {
+      throw new Error(`Failed to save report to ${this.reportPath}: ${error.message}`);
+    }
+  }
+
+  /**
+   * Generate and save installation report
+   *
+   * @param {Object} installationData - Complete installation data
+   * @returns {Promise<string>} Path where report was saved
+   */
+  async createAndSaveReport(installationData) {
+    const reportContent = this.generateReport(installationData);
+    const reportPath = await this.saveReport(reportContent);
+    return reportPath;
+  }
+
+  /**
+   * Get report file path
+   *
+   * @returns {string} Path to report file
+   */
+  getReportPath() {
+    return this.reportPath;
+  }
+
+  // Private helper methods
+
+  _generateHeader() {
+    const timestamp = new Date().toISOString();
+    return `
+╔════════════════════════════════════════════════════════════════╗
+║           AGENTIC-KIT INSTALLATION REPORT                      ║
+╚════════════════════════════════════════════════════════════════╝
+
+Generated: ${timestamp}
+
+`;
+  }
+
+  _generateSummary(summary) {
+    const {
+      success,
+      variant,
+      toolCount,
+      totalFiles,
+      totalSize,
+      duration,
+      errors,
+      warnings
+    } = summary;
+
+    const statusIcon = success ? '✓' : '✗';
+    const statusText = success ? 'SUCCESS' : 'FAILED';
+    const statusLine = `${statusIcon} Installation Status: ${statusText}`;
+
+    return `
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+SUMMARY
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+${statusLine}
+
+Package Variant:    ${variant || 'N/A'}
+Tools Installed:    ${toolCount}
+Total Files:        ${totalFiles}
+Total Size:         ${totalSize}
+Installation Time:  ${duration}
+Errors:             ${errors.length}
+Warnings:           ${warnings.length}
+
+`;
+  }
+
+  _generateToolDetails(tools) {
+    let section = `
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+TOOL DETAILS
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+`;
+
+    tools.forEach((tool, index) => {
+      const {
+        toolId,
+        path: toolPath,
+        filesInstalled,
+        sizeBytes,
+        components = {},
+        verified,
+        verificationStatus,
+        manifestPath
+      } = tool;
+
+      const formattedSize = this._formatSize(sizeBytes || 0);
+      const verificationIcon = verified ? '✓' : '✗';
+      const verificationText = verified ? 'VERIFIED' : 'VERIFICATION FAILED';
+
+      section += `
+${index + 1}. ${toolId.toUpperCase()}
+   ├─ Installation Path:  ${toolPath}
+   ├─ Files Installed:    ${filesInstalled || 0}
+   ├─ Size:              ${formattedSize}
+   ├─ Components:
+   │  ├─ Agents:          ${components.agents || 0}
+   │  ├─ Skills:          ${components.skills || 0}
+   │  ├─ Resources:       ${components.resources || 0}
+   │  └─ Hooks:           ${components.hooks || 0}
+   ├─ Verification:      ${verificationIcon} ${verificationText}`;
+
+      if (verificationStatus) {
+        section += `
+   │  └─ Details:         ${verificationStatus}`;
+      }
+
+      section += `
+   └─ Manifest:          ${manifestPath || 'N/A'}
+`;
+    });
+
+    return section;
+  }
+
+  _generateSystemInfo() {
+    return `
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+SYSTEM INFORMATION
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+Node.js Version:    ${process.version}
+Platform:           ${process.platform}
+Architecture:       ${process.arch}
+Operating System:   ${os.type()} ${os.release()}
+Home Directory:     ${os.homedir()}
+
+`;
+  }
+
+  _generateErrorsSection(errors) {
+    let section = `
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+ERRORS
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+`;
+
+    errors.forEach((error, index) => {
+      section += `${index + 1}. ${error}\n`;
+    });
+
+    section += '\n';
+    return section;
+  }
+
+  _generateWarningsSection(warnings) {
+    let section = `
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+WARNINGS
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+`;
+
+    warnings.forEach((warning, index) => {
+      section += `${index + 1}. ${warning}\n`;
+    });
+
+    section += '\n';
+    return section;
+  }
+
+  _generateFooter() {
+    return `
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+For support and documentation, visit:
+https://github.com/amrhas82/agentflow
+
+Report saved to: ${this.reportPath}
+
+`;
+  }
+
+  _formatDuration(milliseconds) {
+    const seconds = Math.floor(milliseconds / 1000);
+    const minutes = Math.floor(seconds / 60);
+    const remainingSeconds = seconds % 60;
+
+    if (minutes > 0) {
+      return `${minutes}m ${remainingSeconds}s`;
+    }
+    return `${seconds}s`;
+  }
+
+  _formatSize(bytes) {
+    if (bytes === 0) return '0 B';
+    if (bytes < 1024) return `${bytes} B`;
+    if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(2)} KB`;
+    if (bytes < 1024 * 1024 * 1024) return `${(bytes / (1024 * 1024)).toFixed(2)} MB`;
+    return `${(bytes / (1024 * 1024 * 1024)).toFixed(2)} GB`;
+  }
+}
+
+module.exports = ReportTemplate;

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

@@ -0,0 +1,83 @@
+{
+  "name": "liteagents",
+  "version": "2.4.0",
+  "description": "AI development toolkit with 11 specialized agents and 20 commands. Simple one-question installer for Claude, Opencode, Ampcode, and Droid.",
+  "main": "index.js",
+  "bin": {
+    "agentflow": "./installer/cli.js",
+    "agflow": "./cli.js"
+  },
+  "scripts": {
+    "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 ./scripts/validate-package.js",
+    "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",
+    "postinstall": "node postinstall.js"
+  },
+  "keywords": [
+    "claude",
+    "claude-code",
+    "opencode",
+    "ampcode",
+    "droid",
+    "plugin",
+    "installer",
+    "interactive-installer",
+    "multi-tool",
+    "ai-agents",
+    "software-development",
+    "agile",
+    "scrum",
+    "product-management",
+    "development-tools",
+    "workflow-automation",
+    "pdf",
+    "docx",
+    "xlsx",
+    "pptx",
+    "document-generation",
+    "cli",
+    "variant-system"
+  ],
+  "author": "amrhas82 <avoidaccess@msn.com>",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/amrhas82/agentflow.git"
+  },
+  "bugs": {
+    "url": "https://github.com/amrhas82/agentflow/issues"
+  },
+  "homepage": "https://github.com/amrhas82/agentflow#readme",
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org",
+    "access": "public"
+  },
+  "engines": {
+    "node": ">=14.0.0"
+  },
+  "files": [
+    "installer/",
+    "packages/",
+    "tools/",
+    "docs/",
+    "cli.js",
+    "index.js",
+    "postinstall.js",
+    "README.md",
+    "QUICK-START.md",
+    "TROUBLESHOOTING.md",
+    "CHANGELOG.md",
+    "LICENSE"
+  ],
+  "dependencies": {},
+  "devDependencies": {}
+}