@techwavedev/agi-agent-kit 1.1.3

package/CHANGELOG.md

@@ -0,0 +1,59 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [1.1.2] - 2026-01-23
+
+### Added
+
+- **Self-Update Skill**: New `self-update` skill with `update_kit.py` script for easy framework updates.
+- **System Checkup**: New `system_checkup.py` execution script to verify agents, skills, workflows, and scripts.
+- **Workflows**: Added `/checkup` and `/update` workflows for quick access.
+
+### Changed
+
+- Updated `README.md` with comprehensive Quick Start, Commands, and Architecture sections.
+- Updated `SKILLS_CATALOG.md` to include self-update skill.
+
+## [1.1.01] - 2026-01-23
+
+### Fixed
+
+- Stabilized Full Suite activation.
+- Micro-bump for polish releases.
+
+## [1.1.0] - 2026-01-23
+
+### Added
+
+- **Knowledge Pack**: Imported 36+ new skills from `agents-web` including:
+  - `api-patterns`: Best practices for REST/GraphQL/tRPC.
+  - `frontend-design`: UX/UI principles and audit tools.
+  - `security-auditor`: Vulnerability scanning and red-team tactics.
+  - `mobile-design`: iOS/Android development patterns.
+- **Agent Roles**: Added `project-planner`, `orchestrator`, and `security-auditor` agent personas.
+- **Rules**: Added global `deployment_policy` and `clean-code` standards.
+
+### Changed
+
+- Refactored `init` command to support `knowledge` pack.
+- Enhanced `AGENTS.md` with new agent capabilities.
+- Updated `SKILLS_CATALOG.md` with full list of new skills.
+
+## [1.0.1] - 2026-01-23
+
+### Fixed
+
+- **Security**: Removed all references to private infrastructure from public templates.
+- **Safety**: Added `verify_public_release.py` to prevent accidental publication of private secrets.
+- **Menu**: Fixed `init` menu showing internal options.
+
+## [0.1.0] - 2026-01-23
+
+### Initial Release
+
+- Core framework with `webcrawler`, `pdf-reader`, and `qdrant-memory`.
+- CLI tool `agi-agent-kit` for scaffolding.

package/README.md

@@ -0,0 +1,147 @@
+# AGI Agent Kit
+
+**Enterprise-Grade Agentic Framework & Scaffolding Tool**
+
+[![npm version](https://img.shields.io/npm/v/@techwavedev/agi-agent-kit.svg)](https://www.npmjs.com/package/@techwavedev/agi-agent-kit)
+[![License: Apache-2.0](https://img.shields.io/badge/License-Apache%202.0-blue.svg)](https://opensource.org/licenses/Apache-2.0)
+
+`@techwavedev/agi-agent-kit` is a modular, deterministic framework designed to bridge the gap between LLM reasoning and reliable production execution. It scaffolds a "3-Layer Architecture" (Intent → Orchestration → Execution) that forces agents to use tested scripts rather than hallucinating code.
+
+---
+
+## 🚀 Quick Start
+
+Scaffold a new agent workspace in seconds:
+
+```bash
+npx @techwavedev/agi-agent-kit init
+```
+
+You'll be prompted to choose a pack:
+
+- **core** - Essential skills (webcrawler, pdf-reader, qdrant-memory, documentation)
+- **knowledge** - Core + 36 specialized skills (API, Security, Design, Architecture)
+- **full** - Complete suite with `.agent/` structure (agents, workflows, rules)
+
+---
+
+## ✨ Key Features
+
+| Feature                     | Description                                                                |
+| --------------------------- | -------------------------------------------------------------------------- |
+| **Deterministic Execution** | Separates business logic (Python scripts) from AI reasoning (Directives)   |
+| **Modular Skill System**    | Plug-and-play capabilities that can be added or removed instantly          |
+| **Semantic Memory**         | Built-in Qdrant-powered memory with 95% token savings via caching          |
+| **Universal Compatibility** | Works with Claude, Gemini, and OpenAI via standardized context files       |
+| **Self-Healing Workflows**  | Agents read error logs, patch scripts, and update directives automatically |
+| **Self-Update**             | Update to the latest version with a single command                         |
+
+---
+
+## 📦 What You Get
+
+```
+your-project/
+├── AGENTS.md              # Master instruction file (symlinked to GEMINI.md, CLAUDE.md)
+├── skills/                # Pre-built tools
+│   ├── webcrawler/        # Documentation harvesting
+│   ├── pdf-reader/        # PDF text extraction
+│   ├── qdrant-memory/     # Semantic caching & memory
+│   ├── documentation/     # Auto-documentation maintenance
+│   └── self-update/       # Framework self-update capability
+├── directives/            # SOPs in Markdown
+├── execution/             # Deterministic Python scripts
+├── skill-creator/         # Tools to create new skills
+└── .agent/                # (full pack) Agents, workflows, rules
+```
+
+---
+
+## 📖 Architecture
+
+The system operates on three layers:
+
+```
+┌─────────────────────────────────────────────────────────┐
+│  Layer 1: DIRECTIVES (Intent)                           │
+│  └─ SOPs written in Markdown (directives/)              │
+├─────────────────────────────────────────────────────────┤
+│  Layer 2: ORCHESTRATION (Agent)                         │
+│  └─ LLM reads directive, decides which tool to call     │
+├─────────────────────────────────────────────────────────┤
+│  Layer 3: EXECUTION (Code)                              │
+│  └─ Pure Python scripts (execution/) do the actual work │
+└─────────────────────────────────────────────────────────┘
+```
+
+**Why?** LLMs are probabilistic. 90% accuracy per step = 59% success over 5 steps. By pushing complexity into deterministic scripts, we achieve reliable execution.
+
+---
+
+## ⚡ Prerequisites
+
+```bash
+pip install requests beautifulsoup4 html2text lxml qdrant-client
+```
+
+Optional (for semantic memory with local embeddings):
+
+```bash
+pip install ollama sentence-transformers
+```
+
+---
+
+## 🔧 Commands
+
+### Initialize a new project
+
+```bash
+npx @techwavedev/agi-agent-kit init --pack=full
+```
+
+### Update to latest version
+
+```bash
+npx @techwavedev/agi-agent-kit@latest init --pack=full
+# or use the built-in skill:
+python3 skills/self-update/scripts/update_kit.py
+```
+
+### System health check
+
+```bash
+python3 execution/system_checkup.py --verbose
+```
+
+### Create a new skill
+
+```bash
+python3 skill-creator/scripts/init_skill.py my-skill --path skills/
+```
+
+### Update skills catalog
+
+```bash
+python3 skill-creator/scripts/update_catalog.py --skills-dir skills/
+```
+
+---
+
+## 📚 Documentation
+
+- **[AGENTS.md](./AGENTS.md)** - Complete architecture and operating principles
+- **[skills/SKILLS_CATALOG.md](./skills/SKILLS_CATALOG.md)** - All available skills
+- **[CHANGELOG.md](./CHANGELOG.md)** - Version history
+
+---
+
+## 🛡️ Security
+
+This package includes a pre-flight security scanner (`verify_public_release.py`) that checks for private terms before publishing. All templates are sanitized for public use.
+
+---
+
+## 📄 License
+
+Apache-2.0 © [Elton Machado@TechWaveDev](https://github.com/techwavedev)

package/bin/init.js

@@ -0,0 +1,471 @@
+#!/usr/bin/env node
+/**
+ * agi-agent-kit init
+ * 
+ * CLI tool to scaffold AI agent projects with modular skill packs.
+ * 
+ * Usage:
+ *   npx @techwavedev/agi-agent-kit init [--pack=<pack>] [--path=<dir>]
+ * 
+ * Packs:
+ *   core   - Base framework + common skills (webcrawler, pdf-reader, qdrant-memory)
+ * 
+ * Options:
+ *   --path=<dir>    Target directory (default: current)
+ *   --no-symlinks   Skip GEMINI.md/CLAUDE.md symlink creation
+ *   --help          Show help
+ */
+
+const fs = require('fs');
+const path = require('path');
+const readline = require('readline');
+
+// Color utilities for terminal output
+const colors = {
+  reset: '\x1b[0m',
+  bright: '\x1b[1m',
+  green: '\x1b[32m',
+  yellow: '\x1b[33m',
+  blue: '\x1b[34m',
+  cyan: '\x1b[36m',
+  red: '\x1b[31m'
+};
+
+const log = {
+  info: (msg) => console.log(`${colors.cyan}ℹ${colors.reset} ${msg}`),
+  success: (msg) => console.log(`${colors.green}✔${colors.reset} ${msg}`),
+  warn: (msg) => console.log(`${colors.yellow}⚠${colors.reset} ${msg}`),
+  error: (msg) => console.log(`${colors.red}✖${colors.reset} ${msg}`),
+  header: (msg) => console.log(`\n${colors.bright}${colors.blue}${msg}${colors.reset}\n`)
+};
+
+// Pack definitions
+const PACKS = {
+  core: {
+    name: 'Core',
+    description: 'Essential skills (webcrawler, pdf-reader, qdrant-memory, documentation)',
+    skills: ['core']
+  },
+  knowledge: {
+    name: 'Knowledge',
+    description: 'Core + 36 specialized skills (API, Security, Design, Architecture)',
+    skills: ['core', 'knowledge']
+  },
+  full: {
+    name: 'Full Suite',
+    description: 'Complete suite (Core + Knowledge + .agent structure)',
+    skills: ['core', 'knowledge'],
+    includeAgent: true
+  }
+};
+
+// Parse command line arguments
+function parseArgs() {
+  const args = process.argv.slice(2);
+  const options = {
+    command: null,
+    pack: null,
+    path: process.cwd(),
+    symlinks: true,
+    help: false
+  };
+
+  for (const arg of args) {
+    if (arg === 'init') {
+      options.command = 'init';
+    } else if (arg.startsWith('--pack=')) {
+      options.pack = arg.split('=')[1];
+    } else if (arg.startsWith('--path=')) {
+      options.path = path.resolve(arg.split('=')[1]);
+    } else if (arg === '--no-symlinks') {
+      options.symlinks = false;
+    } else if (arg === '--help' || arg === '-h') {
+      options.help = true;
+    }
+  }
+
+  return options;
+}
+
+// Show help message
+function showHelp() {
+  console.log(`
+${colors.bright}agi-agent-kit${colors.reset} - AI Agent Kit Initializer
+
+${colors.bright}Usage:${colors.reset}
+  npx @techwavedev/agi-agent-kit init [options]
+
+${colors.bright}Options:${colors.reset}
+  --pack=<pack>    Select skill pack (core, ec, full)
+  --path=<dir>     Target directory (default: current)
+  --no-symlinks    Skip GEMINI.md/CLAUDE.md symlink creation
+  --help           Show this help message
+
+${colors.bright}Packs:${colors.reset}
+  ${colors.green}core${colors.reset}   Base framework + common skills
+         (webcrawler, pdf-reader, qdrant-memory, documentation)
+
+  ${colors.blue}knowledge${colors.reset} Core + 36 specialized skills
+         (API, Security, Design, Architecture, Testing...)
+  
+  ${colors.yellow}full${colors.reset}      Complete suite
+         (Core + Knowledge + .agent/ structure)
+
+${colors.bright}Examples:${colors.reset}
+  npx @techwavedev/agi-agent-kit init
+  npx @techwavedev/agi-agent-kit init --pack=core
+
+${colors.bright}Note:${colors.reset} Most scripts require ${colors.cyan}python3${colors.reset}.
+`);
+}
+
+// Prompt user for pack selection
+async function promptPackSelection() {
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+
+  return new Promise((resolve) => {
+    console.log(`\n${colors.bright}Which pack would you like to install?${colors.reset}\n`);
+    console.log(`  1. ${colors.green}core${colors.reset}  - Essential skills (webcrawler, pdf-reader, qdrant-memory, documentation)`);
+    console.log(`  2. ${colors.blue}knowledge${colors.reset} - Core + 36 specialized skills (API, Security, Design...)`);
+    console.log(`  3. ${colors.yellow}full${colors.reset}      - Complete suite including .agent/ structure\n`);
+
+    rl.question(`Enter choice (1-3) or pack name (default: core): `, (answer) => {
+      rl.close();
+      const choice = answer.trim().toLowerCase();
+      
+      if (choice === '1' || choice === 'core' || choice === '') resolve('core');
+      else if (choice === '2' || choice === 'knowledge') resolve('knowledge');
+      else if (choice === '3' || choice === 'full') resolve('full');
+      else {
+        log.warn('Invalid choice, defaulting to core');
+        resolve('core');
+      }
+    });
+  });
+}
+
+// Prompt for update components
+async function promptUpdateSelection() {
+  return new Promise((resolve) => {
+    // For now, update implies updating the Full suite or existing installation
+    // We can default to 'full' logic for updates to ensure everything is covered
+    resolve('full');
+  });
+}
+
+// Copy directory recursively
+function copyDirSync(src, dest) {
+  if (!fs.existsSync(src)) {
+    return false;
+  }
+  
+  fs.mkdirSync(dest, { recursive: true });
+  
+  const entries = fs.readdirSync(src, { withFileTypes: true });
+  
+  for (const entry of entries) {
+    const srcPath = path.join(src, entry.name);
+    const destPath = path.join(dest, entry.name);
+    
+    if (entry.isDirectory()) {
+      copyDirSync(srcPath, destPath);
+    } else {
+      fs.copyFileSync(srcPath, destPath);
+    }
+  }
+  
+  return true;
+}
+
+// Create directory structure
+function createStructure(targetPath, options) {
+  log.header('Creating directory structure...');
+  
+  const dirs = [
+    'directives',
+    'execution',
+    'skills',
+    'skill-creator',
+    '.tmp'
+  ];
+  
+  for (const dir of dirs) {
+    const fullPath = path.join(targetPath, dir);
+    fs.mkdirSync(fullPath, { recursive: true });
+    log.success(`Created ${dir}/`);
+  }
+}
+
+// Copy skills based on pack
+function copySkills(targetPath, pack, templatesPath) {
+  log.header(`Installing ${PACKS[pack].name} skills...`);
+  
+  const skillGroups = PACKS[pack].skills;
+  
+  for (const group of skillGroups) {
+    const srcSkillsPath = path.join(templatesPath, 'skills', group);
+    const destSkillsPath = path.join(targetPath, 'skills');
+    
+    if (fs.existsSync(srcSkillsPath)) {
+      const skills = fs.readdirSync(srcSkillsPath, { withFileTypes: true })
+        .filter(d => d.isDirectory())
+        .map(d => d.name);
+      
+      for (const skill of skills) {
+        const src = path.join(srcSkillsPath, skill);
+        const dest = path.join(destSkillsPath, skill);
+        
+        if (copyDirSync(src, dest)) {
+          log.success(`Installed skill: ${skill}`);
+        }
+      }
+    } else {
+      log.warn(`Skills directory not found: ${srcSkillsPath}`);
+    }
+  }
+}
+
+// Copy base files
+function copyBaseFiles(targetPath, templatesPath, options) {
+  log.header('Copying base files...');
+  
+  const baseFiles = [
+    { src: 'AGENTS.md', dest: 'AGENTS.md' },
+    { src: '.gitignore', dest: '.gitignore' },
+    { src: 'requirements.txt', dest: 'requirements.txt' }
+  ];
+  
+  for (const file of baseFiles) {
+    const srcPath = path.join(templatesPath, 'base', file.src);
+    const destPath = path.join(targetPath, file.dest);
+    
+    if (fs.existsSync(srcPath)) {
+      fs.copyFileSync(srcPath, destPath);
+      log.success(`Created ${file.dest}`);
+    }
+  }
+  
+  // Copy skill-creator
+  const srcSkillCreator = path.join(templatesPath, 'base', 'skill-creator');
+  const destSkillCreator = path.join(targetPath, 'skill-creator');
+  
+  if (fs.existsSync(srcSkillCreator)) {
+    copyDirSync(srcSkillCreator, destSkillCreator);
+    log.success('Installed skill-creator/');
+  }
+}
+
+// Create symlinks
+function createSymlinks(targetPath) {
+  log.header('Creating symlinks...');
+  
+  const agentsMd = path.join(targetPath, 'AGENTS.md');
+  
+  if (!fs.existsSync(agentsMd)) {
+    log.warn('AGENTS.md not found, skipping symlinks');
+    return;
+  }
+  
+  const symlinks = [
+    { name: 'GEMINI.md', target: 'AGENTS.md' },
+    { name: 'CLAUDE.md', target: 'AGENTS.md' }
+  ];
+  
+  for (const link of symlinks) {
+    const linkPath = path.join(targetPath, link.name);
+    
+    try {
+      if (fs.existsSync(linkPath)) {
+        fs.unlinkSync(linkPath);
+      }
+      fs.symlinkSync(link.target, linkPath);
+      log.success(`Created symlink: ${link.name} → ${link.target}`);
+    } catch (err) {
+      log.warn(`Failed to create symlink ${link.name}: ${err.message}`);
+    }
+  }
+}
+
+// Copy .agent/ structure for full pack
+function copyAgentStructure(targetPath, templatesPath) {
+  log.header('Installing .agent/ structure...');
+  
+  const srcAgent = path.join(templatesPath, '.agent');
+  const destAgent = path.join(targetPath, '.agent');
+  
+  if (fs.existsSync(srcAgent)) {
+    copyDirSync(srcAgent, destAgent);
+    log.success('Installed .agent/ (agents, workflows, rules)');
+  } else {
+    log.warn('.agent/ template not found');
+  }
+}
+
+// Main init function
+async function init(options) {
+  log.header('🚀 AGI Agent Kit Initializer');
+  
+  // Determine pack
+  let pack = options.pack;
+  if (!pack) {
+    pack = await promptPackSelection();
+  }
+  
+  if (!PACKS[pack]) {
+    log.error(`Unknown pack: ${pack}`);
+    process.exit(1);
+  }
+  
+  log.info(`Installing ${PACKS[pack].name} pack to: ${options.path}`);
+  
+  // Get templates path (relative to this script)
+  const templatesPath = path.join(__dirname, '..', 'templates');
+  
+  if (!fs.existsSync(templatesPath)) {
+    log.error('Templates directory not found. Package may be corrupted.');
+    process.exit(1);
+  }
+  
+  // Create structure
+  createStructure(options.path, options);
+  
+  // Copy base files
+  copyBaseFiles(options.path, templatesPath, options);
+  
+  // Copy skills
+  copySkills(options.path, pack, templatesPath);
+  
+  // Create symlinks
+  if (options.symlinks) {
+    createSymlinks(options.path);
+  }
+  
+  // Copy .agent/ for full pack
+  if (PACKS[pack].includeAgent) {
+    copyAgentStructure(options.path, templatesPath);
+  }
+  
+  // Final message
+  log.header('✨ Installation complete!');
+  console.log(`
+Next steps:
+  1. Review ${colors.cyan}AGENTS.md${colors.reset} for architecture overview
+  2. Install Python dependencies:
+     ${colors.yellow}pip install requests beautifulsoup4 html2text lxml qdrant-client${colors.reset}
+  3. Check ${colors.cyan}skills/${colors.reset} for available capabilities
+  4. Create ${colors.cyan}.env${colors.reset} with your API keys
+  
+Happy coding! 🎉
+`);
+}
+
+// Update function
+async function update(options) {
+  log.header('🔄 AGI Agent Kit Updater');
+
+  if (!fs.existsSync(path.join(options.path, 'AGENTS.md'))) {
+    log.error('AGENTS.md not found. Are you in a valid AGI Agent project?');
+    log.info('Use "init" to start a new project.');
+    process.exit(1);
+  }
+
+  // Default to full pack logic for updates to capture all skills/agents
+  // Users typically want to update their tooling
+  log.info(`Updating framework components in: ${options.path}`);
+  
+  const templatesPath = path.join(__dirname, '..', 'templates');
+  
+  if (!fs.existsSync(templatesPath)) {
+    log.error('Templates directory not found.');
+    process.exit(1);
+  }
+
+  // 1. Update Skills (Core + Knowledge)
+  // We use 'knowledge' pack definition to cover all skills
+  const skillsToUpdate = ['core', 'knowledge'];
+  log.header('Updating Skills...');
+  
+  for (const group of skillsToUpdate) {
+    const srcSkillsPath = path.join(templatesPath, 'skills', group);
+    const destSkillsPath = path.join(options.path, 'skills');
+    
+    if (fs.existsSync(srcSkillsPath)) {
+      const skills = fs.readdirSync(srcSkillsPath, { withFileTypes: true })
+        .filter(d => d.isDirectory())
+        .map(d => d.name);
+      
+      for (const skill of skills) {
+        // Only update if it already exists or if it's new (standard updates usually add new capabilities)
+        const src = path.join(srcSkillsPath, skill);
+        const dest = path.join(destSkillsPath, skill);
+        
+        // We overwrite logic scripts but maybe we should be careful?
+        // For now, standard behavior is to upgrade toolsets.
+        if (copyDirSync(src, dest)) {
+          console.log(`  ${colors.green}✔${colors.reset} Updated: ${skill}`);
+        }
+      }
+    }
+  }
+
+  // 2. Update Agents & Workflows (.agent/)
+  log.header('Updating Agents & Workflows...');
+  const srcAgent = path.join(templatesPath, '.agent');
+  const destAgent = path.join(options.path, '.agent');
+  if (fs.existsSync(srcAgent)) {
+     if (copyDirSync(srcAgent, destAgent)) {
+        console.log(`  ${colors.green}✔${colors.reset} Updated .agent/ directory`);
+     }
+  }
+
+  // 3. Update Skill Creator
+  log.header('Updating Skill Creator...');
+  const srcSC = path.join(templatesPath, 'base', 'skill-creator');
+  const destSC = path.join(options.path, 'skill-creator');
+  if (fs.existsSync(srcSC)) {
+      copyDirSync(srcSC, destSC);
+      console.log(`  ${colors.green}✔${colors.reset} Updated skill-creator/`);
+  }
+
+  // 4. Update Core Documentation if needed
+  // We generally respect user's AGENTS.md, but maybe we update GEMINI.md/CLAUDE.md symlinks?
+  if (options.symlinks) {
+    createSymlinks(options.path);
+  }
+
+  log.header('✨ Update complete!');
+  log.info('Please review any changes to your skills or agents.');
+}
+
+// Entry point
+async function main() {
+  const options = parseArgs();
+  
+  if (options.help) {
+    showHelp();
+    process.exit(0);
+  }
+  
+  if (options.command !== 'init' && options.command !== 'update' && !options.command) {
+    // Default to init if no command specified
+    options.command = 'init';
+  }
+  
+  if (options.command === 'init') {
+    await init(options);
+  } else if (options.command === 'update') {
+    await update(options);
+  } else {
+    log.error(`Unknown command: ${options.command}`);
+    showHelp();
+    process.exit(1);
+  }
+}
+
+main().catch(err => {
+  log.error(`Fatal error: ${err.message}`);
+  process.exit(1);
+});