@techwavedev/agi-agent-kit 1.3.6 → 1.5.0

package/templates/skills/extended/backend/dbos-golang/SKILL.md

@@ -0,0 +1,167 @@
+---
+name: dbos-golang
+description: DBOS Go SDK for building reliable, fault-tolerant applications with durable workflows. Use this skill when writing Go code with DBOS, creating workflows and steps, using queues, using the DBOS Client from external applications, or building Go applications that need to be resilient to failures.
+risk: safe
+source: https://docs.dbos.dev/
+license: MIT
+metadata:
+  author: dbos
+  version: "1.0.0"
+  organization: DBOS
+  date: February 2026
+  abstract: Comprehensive guide for building fault-tolerant Go applications with DBOS. Covers workflows, steps, queues, communication patterns, and best practices for durable execution.
+---
+
+# DBOS Go Best Practices
+
+Guide for building reliable, fault-tolerant Go applications with DBOS durable workflows.
+
+## When to Use
+
+Reference these guidelines when:
+- Adding DBOS to existing Go code
+- Creating workflows and steps
+- Using queues for concurrency control
+- Implementing workflow communication (events, messages, streams)
+- Configuring and launching DBOS applications
+- Using the DBOS Client from external applications
+- Testing DBOS applications
+
+## Rule Categories by Priority
+
+| Priority | Category | Impact | Prefix |
+|----------|----------|--------|--------|
+| 1 | Lifecycle | CRITICAL | `lifecycle-` |
+| 2 | Workflow | CRITICAL | `workflow-` |
+| 3 | Step | HIGH | `step-` |
+| 4 | Queue | HIGH | `queue-` |
+| 5 | Communication | MEDIUM | `comm-` |
+| 6 | Pattern | MEDIUM | `pattern-` |
+| 7 | Testing | LOW-MEDIUM | `test-` |
+| 8 | Client | MEDIUM | `client-` |
+| 9 | Advanced | LOW | `advanced-` |
+
+## Critical Rules
+
+### Installation
+
+Install the DBOS Go module:
+
+```bash
+go get github.com/dbos-inc/dbos-transact-golang/dbos@latest
+```
+
+### DBOS Configuration and Launch
+
+A DBOS application MUST create a context, register workflows, and launch before running any workflows:
+
+```go
+package main
+
+import (
+	"context"
+	"log"
+	"os"
+	"time"
+
+	"github.com/dbos-inc/dbos-transact-golang/dbos"
+)
+
+func main() {
+	ctx, err := dbos.NewDBOSContext(context.Background(), dbos.Config{
+		AppName:     "my-app",
+		DatabaseURL: os.Getenv("DBOS_SYSTEM_DATABASE_URL"),
+	})
+	if err != nil {
+		log.Fatal(err)
+	}
+	defer dbos.Shutdown(ctx, 30*time.Second)
+
+	dbos.RegisterWorkflow(ctx, myWorkflow)
+
+	if err := dbos.Launch(ctx); err != nil {
+		log.Fatal(err)
+	}
+}
+```
+
+### Workflow and Step Structure
+
+Workflows are comprised of steps. Any function performing complex operations or accessing external services must be run as a step using `dbos.RunAsStep`:
+
+```go
+func fetchData(ctx context.Context) (string, error) {
+	resp, err := http.Get("https://api.example.com/data")
+	if err != nil {
+		return "", err
+	}
+	defer resp.Body.Close()
+	body, _ := io.ReadAll(resp.Body)
+	return string(body), nil
+}
+
+func myWorkflow(ctx dbos.DBOSContext, input string) (string, error) {
+	result, err := dbos.RunAsStep(ctx, fetchData, dbos.WithStepName("fetchData"))
+	if err != nil {
+		return "", err
+	}
+	return result, nil
+}
+```
+
+### Key Constraints
+
+- Do NOT start or enqueue workflows from within steps
+- Do NOT use uncontrolled goroutines to start workflows - use `dbos.RunWorkflow` with queues or `dbos.Go`/`dbos.Select` for concurrent steps
+- Workflows MUST be deterministic - non-deterministic operations go in steps
+- Do NOT modify global variables from workflows or steps
+- All workflows and queues MUST be registered before calling `Launch()`
+
+## How to Use
+
+Read individual rule files for detailed explanations and examples:
+
+```
+references/lifecycle-config.md
+references/workflow-determinism.md
+references/queue-concurrency.md
+```
+
+## References
+
+- https://docs.dbos.dev/
+- https://github.com/dbos-inc/dbos-transact-golang
+## 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 dbos-golang <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/extended/backend/dbos-python/SKILL.md

@@ -0,0 +1,136 @@
+---
+name: dbos-python
+description: DBOS Python SDK for building reliable, fault-tolerant applications with durable workflows. Use this skill when writing Python code with DBOS, creating workflows and steps, using queues, using DBOSClient from external applications, or building applications that need to be resilient to failures.
+risk: safe
+source: https://docs.dbos.dev/
+license: MIT
+metadata:
+  author: dbos
+  version: "1.0.0"
+  organization: DBOS
+  date: January 2026
+  abstract: Comprehensive guide for building fault-tolerant Python applications with DBOS. Covers workflows, steps, queues, communication patterns, and best practices for durable execution.
+---
+
+# DBOS Python Best Practices
+
+Guide for building reliable, fault-tolerant Python applications with DBOS durable workflows.
+
+## When to Use
+
+Reference these guidelines when:
+- Adding DBOS to existing Python code
+- Creating workflows and steps
+- Using queues for concurrency control
+- Implementing workflow communication (events, messages, streams)
+- Configuring and launching DBOS applications
+- Using DBOSClient from external applications
+- Testing DBOS applications
+
+## Rule Categories by Priority
+
+| Priority | Category | Impact | Prefix |
+|----------|----------|--------|--------|
+| 1 | Lifecycle | CRITICAL | `lifecycle-` |
+| 2 | Workflow | CRITICAL | `workflow-` |
+| 3 | Step | HIGH | `step-` |
+| 4 | Queue | HIGH | `queue-` |
+| 5 | Communication | MEDIUM | `comm-` |
+| 6 | Pattern | MEDIUM | `pattern-` |
+| 7 | Testing | LOW-MEDIUM | `test-` |
+| 8 | Client | MEDIUM | `client-` |
+| 9 | Advanced | LOW | `advanced-` |
+
+## Critical Rules
+
+### DBOS Configuration and Launch
+
+A DBOS application MUST configure and launch DBOS inside its main function:
+
+```python
+import os
+from dbos import DBOS, DBOSConfig
+
+@DBOS.workflow()
+def my_workflow():
+    pass
+
+if __name__ == "__main__":
+    config: DBOSConfig = {
+        "name": "my-app",
+        "system_database_url": os.environ.get("DBOS_SYSTEM_DATABASE_URL"),
+    }
+    DBOS(config=config)
+    DBOS.launch()
+```
+
+### Workflow and Step Structure
+
+Workflows are comprised of steps. Any function performing complex operations or accessing external services must be a step:
+
+```python
+@DBOS.step()
+def call_external_api():
+    return requests.get("https://api.example.com").json()
+
+@DBOS.workflow()
+def my_workflow():
+    result = call_external_api()
+    return result
+```
+
+### Key Constraints
+
+- Do NOT call `DBOS.start_workflow` or `DBOS.recv` from a step
+- Do NOT use threads to start workflows - use `DBOS.start_workflow` or queues
+- Workflows MUST be deterministic - non-deterministic operations go in steps
+- Do NOT create/update global variables from workflows or steps
+
+## How to Use
+
+Read individual rule files for detailed explanations and examples:
+
+```
+references/lifecycle-config.md
+references/workflow-determinism.md
+references/queue-concurrency.md
+```
+
+## References
+
+- https://docs.dbos.dev/
+- https://github.com/dbos-inc/dbos-transact-py
+## 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 dbos-python <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/extended/backend/dbos-typescript/SKILL.md

@@ -0,0 +1,145 @@
+---
+name: dbos-typescript
+description: DBOS TypeScript SDK for building reliable, fault-tolerant applications with durable workflows. Use this skill when writing TypeScript code with DBOS, creating workflows and steps, using queues, using DBOSClient from external applications, or building applications that need to be resilient to failures.
+risk: safe
+source: https://docs.dbos.dev/
+license: MIT
+metadata:
+  author: dbos
+  version: "1.0.0"
+  organization: DBOS
+  date: January 2026
+  abstract: Comprehensive guide for building fault-tolerant TypeScript applications with DBOS. Covers workflows, steps, queues, communication patterns, and best practices for durable execution.
+---
+
+# DBOS TypeScript Best Practices
+
+Guide for building reliable, fault-tolerant TypeScript applications with DBOS durable workflows.
+
+## When to Use
+
+Reference these guidelines when:
+- Adding DBOS to existing TypeScript code
+- Creating workflows and steps
+- Using queues for concurrency control
+- Implementing workflow communication (events, messages, streams)
+- Configuring and launching DBOS applications
+- Using DBOSClient from external applications
+- Testing DBOS applications
+
+## Rule Categories by Priority
+
+| Priority | Category | Impact | Prefix |
+|----------|----------|--------|--------|
+| 1 | Lifecycle | CRITICAL | `lifecycle-` |
+| 2 | Workflow | CRITICAL | `workflow-` |
+| 3 | Step | HIGH | `step-` |
+| 4 | Queue | HIGH | `queue-` |
+| 5 | Communication | MEDIUM | `comm-` |
+| 6 | Pattern | MEDIUM | `pattern-` |
+| 7 | Testing | LOW-MEDIUM | `test-` |
+| 8 | Client | MEDIUM | `client-` |
+| 9 | Advanced | LOW | `advanced-` |
+
+## Critical Rules
+
+### Installation
+
+Always install the latest version of DBOS:
+
+```bash
+npm install @dbos-inc/dbos-sdk@latest
+```
+
+### DBOS Configuration and Launch
+
+A DBOS application MUST configure and launch DBOS before running any workflows:
+
+```typescript
+import { DBOS } from "@dbos-inc/dbos-sdk";
+
+async function main() {
+  DBOS.setConfig({
+    name: "my-app",
+    systemDatabaseUrl: process.env.DBOS_SYSTEM_DATABASE_URL,
+  });
+  await DBOS.launch();
+  await myWorkflow();
+}
+
+main().catch(console.log);
+```
+
+### Workflow and Step Structure
+
+Workflows are comprised of steps. Any function performing complex operations or accessing external services must be run as a step using `DBOS.runStep`:
+
+```typescript
+import { DBOS } from "@dbos-inc/dbos-sdk";
+
+async function fetchData() {
+  return await fetch("https://api.example.com").then(r => r.json());
+}
+
+async function myWorkflowFn() {
+  const result = await DBOS.runStep(fetchData, { name: "fetchData" });
+  return result;
+}
+const myWorkflow = DBOS.registerWorkflow(myWorkflowFn);
+```
+
+### Key Constraints
+
+- Do NOT call, start, or enqueue workflows from within steps
+- Do NOT use threads or uncontrolled concurrency to start workflows - use `DBOS.startWorkflow` or queues
+- Workflows MUST be deterministic - non-deterministic operations go in steps
+- Do NOT modify global variables from workflows or steps
+
+## How to Use
+
+Read individual rule files for detailed explanations and examples:
+
+```
+references/lifecycle-config.md
+references/workflow-determinism.md
+references/queue-concurrency.md
+```
+
+## References
+
+- https://docs.dbos.dev/
+- https://github.com/dbos-inc/dbos-transact-ts
+## 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 dbos-typescript <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/extended/backend/laravel-expert/SKILL.md

@@ -0,0 +1,219 @@
+---
+name: laravel-expert
+description: Senior Laravel Engineer role for production-grade, maintainable, and idiomatic Laravel solutions. Focuses on clean architecture, security, performance, and modern standards (Laravel 10/11+).
+risk: safe
+source: community
+---
+
+# Laravel Expert
+
+## Skill Metadata
+
+Name: laravel-expert  
+Focus: General Laravel Development  
+Scope: Laravel Framework (10/11+)
+
+---
+
+## Role
+
+You are a Senior Laravel Engineer.
+
+You provide production-grade, maintainable, and idiomatic Laravel solutions.
+
+You prioritize:
+
+- Clean architecture
+- Readability
+- Testability
+- Security best practices
+- Performance awareness
+- Convention over configuration
+
+You follow modern Laravel standards and avoid legacy patterns unless explicitly required.
+
+---
+
+## Use This Skill When
+
+- Building new Laravel features
+- Refactoring legacy Laravel code
+- Designing APIs
+- Creating validation logic
+- Implementing authentication/authorization
+- Structuring services and business logic
+- Optimizing database interactions
+- Reviewing Laravel code quality
+
+---
+
+## Do NOT Use When
+
+- The project is not Laravel-based
+- The task is framework-agnostic PHP only
+- The user requests non-PHP solutions
+- The task is unrelated to backend engineering
+
+---
+
+## Engineering Principles
+
+### Architecture
+
+- Keep controllers thin
+- Move business logic into Services
+- Use FormRequest for validation
+- Use API Resources for API responses
+- Use Policies/Gates for authorization
+- Apply Dependency Injection
+- Avoid static abuse and global state
+
+### Routing
+
+- Use route model binding
+- Group routes logically
+- Apply middleware properly
+- Separate web and api routes
+
+### Validation
+
+- Always validate input
+- Never use request()->all() blindly
+- Prefer FormRequest classes
+- Return structured validation errors for APIs
+
+### Eloquent & Database
+
+- Use guarded/fillable correctly
+- Avoid N+1 (use eager loading)
+- Prefer query scopes for reusable filters
+- Avoid raw queries unless necessary
+- Use transactions for critical operations
+
+### API Development
+
+- Use API Resources
+- Standardize JSON structure
+- Use proper HTTP status codes
+- Implement pagination
+- Apply rate limiting
+
+### Authentication
+
+- Use Laravel’s native auth system
+- Prefer Sanctum for SPA/API
+- Implement password hashing securely
+- Never expose sensitive data in responses
+
+### Queues & Jobs
+
+- Offload heavy operations to queues
+- Use dispatchable jobs
+- Ensure idempotency where needed
+
+### Caching
+
+- Cache expensive queries
+- Use cache tags if supported
+- Invalidate cache properly
+
+### Blade & Views
+
+- Escape user input
+- Avoid business logic in views
+- Use components for reuse
+
+---
+
+## Anti-Patterns to Avoid
+
+- Fat controllers
+- Business logic in routes
+- Massive service classes
+- Direct model manipulation without validation
+- Blind mass assignment
+- Hardcoded configuration values
+- Duplicated logic across controllers
+
+---
+
+## Response Standards
+
+When generating code:
+
+- Provide complete, production-ready examples
+- Include namespace declarations
+- Use strict typing when possible
+- Follow PSR standards
+- Use proper return types
+- Add minimal but meaningful comments
+- Do not over-engineer
+
+When reviewing code:
+
+- Identify structural problems
+- Suggest Laravel-native improvements
+- Explain tradeoffs clearly
+- Provide refactored example if necessary
+
+---
+
+## Output Structure
+
+When designing a feature:
+
+1. Architecture Overview
+2. File Structure
+3. Code Implementation
+4. Explanation
+5. Possible Improvements
+
+When refactoring:
+
+1. Identified Issues
+2. Refactored Version
+3. Why It’s Better
+
+---
+
+## Behavioral Constraints
+
+- Prefer Laravel-native solutions over third-party packages
+- Avoid unnecessary abstractions
+- Do not introduce microservice architecture unless requested
+- Do not assume cloud infrastructure
+- Keep solutions pragmatic and realistic
+## 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 laravel-expert <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