@techwavedev/agi-agent-kit 1.3.6 → 1.4.2

package/templates/skills/knowledge/workflow/app-builder/templates/SKILL.md

@@ -37,3 +37,38 @@ allowed-tools: Read, Glob, Grep
 2. Match to appropriate template
 3. Read ONLY that template's TEMPLATE.md
 4. Follow its tech stack and structure
+
+## AGI Framework Integration
+
+### Qdrant Memory Integration
+
+Before executing complex tasks with this skill:
+```bash
+python3 execution/memory_manager.py auto --query "<task summary>"
+```
+
+**Decision Tree:**
+- **Cache hit?** Use cached response directly — no need to re-process.
+- **Memory match?** Inject `context_chunks` into your reasoning.
+- **No match?** Proceed normally, then store results:
+
+```bash
+python3 execution/memory_manager.py store \
+  --content "Description of what was decided/solved" \
+  --type decision \
+  --tags templates <relevant-tags>
+```
+
+> **Note:** Storing automatically updates both Vector (Qdrant) and Keyword (BM25) indices.
+
+### Agent Team Collaboration
+
+- **Strategy**: This skill communicates via the shared memory system.
+- **Orchestration**: Invoked by `orchestrator` via intelligent routing.
+- **Context Sharing**: Always read previous agent outputs from memory before starting.
+
+### Local LLM Support
+
+When available, use local Ollama models for embedding and lightweight inference:
+- Embeddings: `nomic-embed-text` via Qdrant memory system
+- Lightweight analysis: Local models reduce API costs for repetitive patterns

package/templates/skills/knowledge/workflow/behavioral-modes/SKILL.md

@@ -240,3 +240,38 @@ Users can explicitly request a mode:
 /debug why login fails
 /review this pull request
 ```
+
+## AGI Framework Integration
+
+### Qdrant Memory Integration
+
+Before executing complex tasks with this skill:
+```bash
+python3 execution/memory_manager.py auto --query "<task summary>"
+```
+
+**Decision Tree:**
+- **Cache hit?** Use cached response directly — no need to re-process.
+- **Memory match?** Inject `context_chunks` into your reasoning.
+- **No match?** Proceed normally, then store results:
+
+```bash
+python3 execution/memory_manager.py store \
+  --content "Description of what was decided/solved" \
+  --type decision \
+  --tags behavioral-modes <relevant-tags>
+```
+
+> **Note:** Storing automatically updates both Vector (Qdrant) and Keyword (BM25) indices.
+
+### Agent Team Collaboration
+
+- **Strategy**: This skill communicates via the shared memory system.
+- **Orchestration**: Invoked by `orchestrator` via intelligent routing.
+- **Context Sharing**: Always read previous agent outputs from memory before starting.
+
+### Local LLM Support
+
+When available, use local Ollama models for embedding and lightweight inference:
+- Embeddings: `nomic-embed-text` via Qdrant memory system
+- Lightweight analysis: Local models reduce API costs for repetitive patterns

package/templates/skills/knowledge/workflow/clean-code/SKILL.md

@@ -199,3 +199,37 @@ File to edit: UserService.ts
 > 🔴 **VIOLATION:** Auto-fixing without asking = Not allowed.
 > 🔴 **Rule:** Always READ output → SUMMARIZE → ASK → then fix.
 
+## AGI Framework Integration
+
+### Qdrant Memory Integration
+
+Before executing complex tasks with this skill:
+```bash
+python3 execution/memory_manager.py auto --query "<task summary>"
+```
+
+**Decision Tree:**
+- **Cache hit?** Use cached response directly — no need to re-process.
+- **Memory match?** Inject `context_chunks` into your reasoning.
+- **No match?** Proceed normally, then store results:
+
+```bash
+python3 execution/memory_manager.py store \
+  --content "Description of what was decided/solved" \
+  --type decision \
+  --tags clean-code <relevant-tags>
+```
+
+> **Note:** Storing automatically updates both Vector (Qdrant) and Keyword (BM25) indices.
+
+### Agent Team Collaboration
+
+- **Strategy**: This skill communicates via the shared memory system.
+- **Orchestration**: Invoked by `orchestrator` via intelligent routing.
+- **Context Sharing**: Always read previous agent outputs from memory before starting.
+
+### Local LLM Support
+
+When available, use local Ollama models for embedding and lightweight inference:
+- Embeddings: `nomic-embed-text` via Qdrant memory system
+- Lightweight analysis: Local models reduce API costs for repetitive patterns

package/templates/skills/knowledge/workflow/deployment-procedures/SKILL.md

@@ -239,3 +239,38 @@ Before deploying:
 ---
 
 > **Remember:** Every deployment is a risk. Minimize risk through preparation, not speed.
+
+## 🧠 AGI Framework Integration
+
+### Hybrid Memory Integration (Qdrant + BM25)
+
+Before executing complex tasks with this skill:
+```bash
+python3 execution/memory_manager.py auto --query "<task summary>"
+```
+
+**Decision Tree:**
+- **Cache hit?** Use cached response directly — no need to re-process.
+- **Memory match?** Inject `context_chunks` into your reasoning.
+- **No match?** Proceed normally, then store results:
+
+```bash
+python3 execution/memory_manager.py store \
+  --content "Description of what was decided/solved" \
+  --type decision \
+  --tags deployment-procedures <relevant-tags>
+```
+
+> **Note:** Storing automatically updates both Vector (Qdrant) and Keyword (BM25) indices.
+
+### Agent Team Collaboration
+
+- **Strategy**: This skill communicates via the shared memory system.
+- **Orchestration**: Invoked by `orchestrator` via intelligent routing.
+- **Context Sharing**: Always read previous agent outputs from memory before starting.
+
+### Local LLM Support
+
+When available, use local Ollama models for embedding and lightweight inference:
+- Embeddings: `nomic-embed-text` via Qdrant memory system
+- Lightweight analysis: Local models reduce API costs for repetitive patterns

package/templates/skills/knowledge/workflow/intelligent-routing/SKILL.md

@@ -405,3 +405,38 @@ User: "Run these 5 reviews in parallel"
 ✅ Fallback to orchestrator for complex tasks
 
 **Result**: User gets specialist-level responses with the best available parallelism, regardless of platform.
+
+## AGI Framework Integration
+
+### Qdrant Memory Integration
+
+Before executing complex tasks with this skill:
+```bash
+python3 execution/memory_manager.py auto --query "<task summary>"
+```
+
+**Decision Tree:**
+- **Cache hit?** Use cached response directly — no need to re-process.
+- **Memory match?** Inject `context_chunks` into your reasoning.
+- **No match?** Proceed normally, then store results:
+
+```bash
+python3 execution/memory_manager.py store \
+  --content "Description of what was decided/solved" \
+  --type decision \
+  --tags intelligent-routing <relevant-tags>
+```
+
+> **Note:** Storing automatically updates both Vector (Qdrant) and Keyword (BM25) indices.
+
+### Agent Team Collaboration
+
+- **Strategy**: This skill communicates via the shared memory system.
+- **Orchestration**: Invoked by `orchestrator` via intelligent routing.
+- **Context Sharing**: Always read previous agent outputs from memory before starting.
+
+### Local LLM Support
+
+When available, use local Ollama models for embedding and lightweight inference:
+- Embeddings: `nomic-embed-text` via Qdrant memory system
+- Lightweight analysis: Local models reduce API costs for repetitive patterns

package/templates/skills/knowledge/workflow/plugin-discovery/SKILL.md

@@ -579,3 +579,38 @@ Would you like me to install the recommended extensions? (y/n)
 4. **Respect scopes** — Use project scope for team tools, user scope for personal preferences
 5. **Proactive but not pushy** — Suggest once per session, don't repeat
 6. **Cross-platform awareness** — When a skill exists as both Antigravity SKILL.md and Kiro POWER.md, use the native format for the detected platform
+
+## AGI Framework Integration
+
+### Qdrant Memory Integration
+
+Before executing complex tasks with this skill:
+```bash
+python3 execution/memory_manager.py auto --query "<task summary>"
+```
+
+**Decision Tree:**
+- **Cache hit?** Use cached response directly — no need to re-process.
+- **Memory match?** Inject `context_chunks` into your reasoning.
+- **No match?** Proceed normally, then store results:
+
+```bash
+python3 execution/memory_manager.py store \
+  --content "Description of what was decided/solved" \
+  --type decision \
+  --tags plugin-discovery <relevant-tags>
+```
+
+> **Note:** Storing automatically updates both Vector (Qdrant) and Keyword (BM25) indices.
+
+### Agent Team Collaboration
+
+- **Strategy**: This skill communicates via the shared memory system.
+- **Orchestration**: Invoked by `orchestrator` via intelligent routing.
+- **Context Sharing**: Always read previous agent outputs from memory before starting.
+
+### Local LLM Support
+
+When available, use local Ollama models for embedding and lightweight inference:
+- Embeddings: `nomic-embed-text` via Qdrant memory system
+- Lightweight analysis: Local models reduce API costs for repetitive patterns

package/templates/skills/knowledge/workflow/self-update/SKILL.md

@@ -58,3 +58,38 @@ python3 skills/self-update/scripts/update_kit.py
 - The update process **overwrites** skill scripts. If you've customized them, back up first.
 - Your `.env` and custom directives are always preserved.
 - After updating, run `/checkup` to verify everything is working.
+
+## AGI Framework Integration
+
+### Qdrant Memory Integration
+
+Before executing complex tasks with this skill:
+```bash
+python3 execution/memory_manager.py auto --query "<task summary>"
+```
+
+**Decision Tree:**
+- **Cache hit?** Use cached response directly — no need to re-process.
+- **Memory match?** Inject `context_chunks` into your reasoning.
+- **No match?** Proceed normally, then store results:
+
+```bash
+python3 execution/memory_manager.py store \
+  --content "Description of what was decided/solved" \
+  --type decision \
+  --tags self-update <relevant-tags>
+```
+
+> **Note:** Storing automatically updates both Vector (Qdrant) and Keyword (BM25) indices.
+
+### Agent Team Collaboration
+
+- **Strategy**: This skill communicates via the shared memory system.
+- **Orchestration**: Invoked by `orchestrator` via intelligent routing.
+- **Context Sharing**: Always read previous agent outputs from memory before starting.
+
+### Local LLM Support
+
+When available, use local Ollama models for embedding and lightweight inference:
+- Embeddings: `nomic-embed-text` via Qdrant memory system
+- Lightweight analysis: Local models reduce API costs for repetitive patterns

package/templates/skills/knowledge/workflow/verification-before-completion/SKILL.md

@@ -155,3 +155,38 @@ If you catch yourself thinking:
 Run the command. Read the output. THEN claim the result.
 
 This is non-negotiable.
+
+## AGI Framework Integration
+
+### Qdrant Memory Integration
+
+Before executing complex tasks with this skill:
+```bash
+python3 execution/memory_manager.py auto --query "<task summary>"
+```
+
+**Decision Tree:**
+- **Cache hit?** Use cached response directly — no need to re-process.
+- **Memory match?** Inject `context_chunks` into your reasoning.
+- **No match?** Proceed normally, then store results:
+
+```bash
+python3 execution/memory_manager.py store \
+  --content "Description of what was decided/solved" \
+  --type decision \
+  --tags verification-before-completion <relevant-tags>
+```
+
+> **Note:** Storing automatically updates both Vector (Qdrant) and Keyword (BM25) indices.
+
+### Agent Team Collaboration
+
+- **Strategy**: This skill communicates via the shared memory system.
+- **Orchestration**: Invoked by `orchestrator` via intelligent routing.
+- **Context Sharing**: Always read previous agent outputs from memory before starting.
+
+### Local LLM Support
+
+When available, use local Ollama models for embedding and lightweight inference:
+- Embeddings: `nomic-embed-text` via Qdrant memory system
+- Lightweight analysis: Local models reduce API costs for repetitive patterns

package/templates/base/.agent/scripts/release_gate.py

@@ -1,148 +0,0 @@
-#!/usr/bin/env python3
-"""
-Script: release_gate.py
-Purpose: Enforce strict quality checks before release (npm publish or public merge).
-Checks:
-1. Documentation (README/CHANGELOG updated?)
-2. Security (Secret scanning)
-3. Code Integrity (Syntax check)
-4. Version Consistency (package.json)
-"""
-
-import json
-import os
-import re
-import subprocess
-import sys
-from pathlib import Path
-
-# Configuration
-ROOT_DIR = Path(__file__).resolve().parent.parent.parent
-SENSITIVE_PATTERNS = [
-    r"(?i)aws_access_key_id\s*=\s*['\"](AKIA[0-9A-Z]{16})['\"]",
-    r"(?i)api_key\s*=\s*['\"](sk-[a-zA-Z0-9]{32,})['\"]",
-    r"(?i)private_key\s*=\s*['\"](-----BEGIN PRIVATE KEY-----)['\"]",
-]
-REQUIRED_DOCS = ["README.md", "CHANGELOG.md"]
-
-def run_command(cmd, cwd=ROOT_DIR):
-    """Run a shell command and return output."""
-    try:
-        result = subprocess.run(
-            cmd, shell=True, check=True, capture_output=True, text=True, cwd=cwd
-        )
-        return result.stdout.strip()
-    except subprocess.CalledProcessError as e:
-        print(f"❌ Command failed: {cmd}")
-        print(e.stderr)
-        return None
-
-def check_git_status():
-    """Ensure working directory is clean."""
-    print("🔍 Checking Git status...")
-    status = run_command("git status --porcelain")
-    if status:
-        print("⚠️  Uncommitted changes detected:")
-        print(status)
-        response = input("Continue anyway? (y/N): ")
-        if response.lower() != 'y':
-            sys.exit(1)
-    else:
-        print("✅ Git working directory clean.")
-
-def check_documentation():
-    """Verify documentation updates."""
-    print("🔍 Verifying documentation...")
-    for doc in REQUIRED_DOCS:
-        if not (ROOT_DIR / doc).exists():
-            print(f"❌ Missing required document: {doc}")
-            sys.exit(1)
-        
-        # Check if modified in last commit (optional but good practice)
-        # diff = run_command(f"git diff head --name-only | grep {doc}")
-        # if diff:
-        #     print(f"✅ {doc} updated in staged/recent changes.")
-        
-    print("✅ Documentation present.")
-
-def scan_secrets():
-    """Scan for hardcoded secrets."""
-    print("🔍 Scanning for secrets...")
-    issues = []
-    # Scan python, js, md files
-    for ext in ["py", "js", "md", "json"]:
-        for path in ROOT_DIR.rglob(f"*.{ext}"):
-            if "node_modules" in str(path) or ".git" in str(path):
-                continue
-            try:
-                content = path.read_text(errors="ignore")
-                for pattern in SENSITIVE_PATTERNS:
-                    match = re.search(pattern, content)
-                    if match:
-                        issues.append(f"{path}: Potential secret found via regex")
-            except Exception:
-                pass
-
-    if issues:
-        print("❌ Security issues found:")
-        for issue in issues:
-            print(f"   - {issue}")
-        sys.exit(1)
-    print("✅ No hardcoded secrets found.")
-
-def check_versions():
-    """Check package.json version matches changelog."""
-    print("🔍 Checking version consistency...")
-    pkg_json = ROOT_DIR / "package.json"
-    changelog = ROOT_DIR / "CHANGELOG.md"
-    
-    if pkg_json.exists():
-        data = json.loads(pkg_json.read_text())
-        version = data.get("version")
-        print(f"ℹ️  Package version: {version}")
-        
-        if changelog.exists():
-            content = changelog.read_text()
-            if version not in content:
-                print(f"⚠️  Version {version} not found in CHANGELOG.md!")
-                response = input("Continue anyway? (y/N): ")
-                if response.lower() != 'y':
-                    sys.exit(1)
-            else:
-                print("✅ Version present in CHANGELOG.")
-
-def syntax_check():
-    """Run basic syntax check."""
-    print("🔍 verifying Python syntax...")
-    # Find all python files
-    py_files = list(ROOT_DIR.rglob("*.py"))
-    failed = False
-    for py in py_files:
-        if "node_modules" in str(py) or ".venv" in str(py):
-            continue
-        try:
-            subprocess.run(["python3", "-m", "py_compile", str(py)], check=True, capture_output=True)
-        except subprocess.CalledProcessError:
-            print(f"❌ Syntax error in {py}")
-            failed = True
-    
-    if failed:
-        sys.exit(1)
-    print("✅ Python syntax valid.")
-
-def main():
-    print("🚀 Starting Release Gate Protocol...")
-    print("-----------------------------------")
-    
-    check_git_status()
-    check_documentation()
-    scan_secrets()
-    check_versions()
-    syntax_check()
-    
-    print("-----------------------------------")
-    print("✅ All checks passed. Ready for release.")
-    sys.exit(0)
-
-if __name__ == "__main__":
-    main()

package/templates/base/.agent/workflows/release-protocol.md

@@ -1,43 +0,0 @@
----
-description: Comprehensive Release Protocol for Agi Agent Kit. Enforces documentation reviews, security scans, and version checks before any publish or public merge.
----
-
-## Release Governance Protocol (MANDATORY)
-
-Before merging to `public` branch or running `npm publish`, execute this protocol.
-
-### 1. Preparation
-
-- [ ] Ensure `CHANGELOG.md` is updated with all features/fixes.
-- [ ] Ensure `package.json` version is bumped correctly (semver).
-- [ ] Review `README.md` for any API changes.
-
-### 2. Automated Gate
-
-Run the Release Gate script to enforce checks:
-
-```bash
-python3 .agent/scripts/release_gate.py
-```
-
-This script will verify:
-
-- Git status (clean working tree)
-- Documentation presence
-- Secret scanning (no API keys)
-- Version consistency
-- Python syntax validity
-
-### 3. Manual Review
-
-- [ ] Check if `AGENTS.md` reflects new capabilities.
-- [ ] Verify `memory_integration.md` if memory system changed.
-- [ ] Ensure no temporary files in `execution/` or `skills/` unless intended.
-
-### 4. Publish
-
-Only proceed if Step 2 passes.
-
-```bash
-npm publish --access public
-```