@itz4blitz/agentful 1.0.1 → 1.1.0

package/README.md

@@ -1,16 +1,583 @@
 # agentful
 
-A carrot on a stick for Claude Code
+Pre-configured AI agent toolkit with self-hosted remote execution
 
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
 [![npm version](https://badge.fury.io/js/%40itz4blitz%2Fagentful.svg)](https://www.npmjs.com/package/@itz4blitz/agentful)
 [![CI Status](https://github.com/itz4blitz/agentful/actions/workflows/pipeline.yml/badge.svg)](https://github.com/itz4blitz/agentful/actions)
 
-## Overview
+Run specialized AI agents on your infrastructure with full control over data, costs, and integrations. Deploy to Oracle Cloud's free tier ($0/month), integrate with any CI/CD platform, and get agents that understand YOUR codebase.
 
-agentful is a Claude Code configuration that provides structured development through specialized AI agents. It coordinates multiple agents to implement features, write tests, and validate code quality according to a defined product specification.
+---
 
-## Web Configurator
+## Why agentful?
+
+### Self-Hosted Remote Agent Execution
+
+Run AI agents on **your infrastructure** with complete control:
+
+- **$0/month on Oracle Cloud free tier**: 4 ARM cores, 24GB RAM, always free
+- **Three authentication modes**: Tailscale (recommended), HMAC for public endpoints, SSH tunnel for local development
+- **Own your data**: All code analysis and execution happens on your servers
+- **No vendor lock-in**: Standard HTTP API, works with any client
+- **Secure by default**: WireGuard encryption (Tailscale), request signing (HMAC), or localhost-only (SSH)
+
+```bash
+# Deploy to Oracle Cloud free tier
+agentful serve --auth=tailscale
+
+# Or run locally with SSH tunnel
+ssh -L 3000:localhost:3000 your-server
+agentful serve --auth=none
+```
+
+### Multi-Platform CI/CD Integration
+
+**Not locked to GitHub Actions** - works with any CI/CD platform:
+
+- **GitHub Actions**: Native integration with workflow examples
+- **GitLab CI**: Pipeline templates with caching and artifacts
+- **Jenkins**: Groovy pipeline scripts for declarative/scripted pipelines
+- **CircleCI, Bitbucket, Travis**: Use the HTTP API from any platform
+- **Custom platforms**: Standard REST API for any HTTP client
+
+```bash
+# Generate workflow for your CI platform
+agentful ci --generate-workflow
+
+# Or integrate via HTTP API from any platform
+curl -X POST http://your-server:3000/agent/orchestrator \
+  -H "Content-Type: application/json" \
+  -d '{"task": "implement feature X"}'
+```
+
+### Complete Agent Development Toolkit
+
+Everything you need for structured AI-driven development:
+
+- **8 specialized agents**: orchestrator, architect, backend, frontend, tester, reviewer, fixer, product-analyzer
+- **6 reusable skills**: product-tracking, validation, testing, conversation, product-planning, deployment
+- **6 quality gates**: Type checking, linting, test execution, coverage, security scanning, dead code detection
+- **Interactive product planning**: Smart Q&A to build and validate specifications
+- **State management**: Track progress, decisions, and completion across sessions
+- **Smart updates**: 3-way merge preserves customizations during upgrades
+
+### Auto-Generates Domain-Specific Agents
+
+Agents that understand **YOUR codebase**, not generic templates:
+
+- **Analyzes your patterns**: File organization, coding conventions, import styles, error handling
+- **Detects tech stack**: Framework, language, database, ORM, testing tools
+- **Generates specialized agents**: Real code examples from YOUR project
+- **Confidence scoring**: See how well agents match your architecture (0.4-1.0)
+- **Continuous refinement**: Re-analyzes after implementations to improve accuracy
+
+**New projects**: Start with best-practice templates (0.4 confidence), then auto-refine after first feature.
+**Existing projects**: Immediate high-confidence agents (0.8-1.0) from your actual code.
+
+---
+
+## Quick Start
+
+### 1. Install agentful
+
+```bash
+npx @itz4blitz/agentful init
+```
+
+This installs all components (8 agents, 6 skills, quality gates) and auto-detects your tech stack.
+
+### 2. Define your product
+
+```bash
+claude  # Start Claude Code
+/agentful-product
+```
+
+Interactive Q&A creates your product specification with readiness scoring.
+
+### 3. Generate domain-specific agents
+
+```bash
+/agentful-analyze
+```
+
+Analyzes your codebase and generates specialized agents matching your patterns.
+
+### 4. Start development
+
+```bash
+/agentful-start
+```
+
+Orchestrator coordinates agents to implement features with quality gates.
+
+---
+
+## Remote Execution
+
+Run agentful agents on remote servers via secure HTTP API.
+
+### Authentication Modes
+
+#### Tailscale (Recommended)
+
+Uses WireGuard encryption for secure remote access:
+
+```bash
+# Install Tailscale
+curl -fsSL https://tailscale.com/install.sh | sh
+tailscale up
+
+# Start server (listens on Tailscale IP only)
+agentful serve --auth=tailscale
+```
+
+**Benefits**:
+- End-to-end encrypted (WireGuard)
+- No public IP needed
+- Works across NAT/firewalls
+- Access from anywhere securely
+
+#### HMAC (Public Endpoints)
+
+Signature-based authentication with replay protection:
+
+```bash
+# Generate secret
+export SECRET=$(openssl rand -hex 32)
+
+# Start server with HMAC auth and HTTPS
+agentful serve --auth=hmac --secret=$SECRET --https --cert=cert.pem --key=key.pem
+```
+
+**Client usage**:
+
+```bash
+# Calculate HMAC signature
+TIMESTAMP=$(date +%s)
+SIGNATURE=$(echo -n "${TIMESTAMP}${PAYLOAD}" | openssl dgst -sha256 -hmac "$SECRET" -binary | base64)
+
+curl -X POST https://your-server:3000/agent/orchestrator \
+  -H "Content-Type: application/json" \
+  -H "X-Timestamp: $TIMESTAMP" \
+  -H "X-Signature: $SIGNATURE" \
+  -d "$PAYLOAD"
+```
+
+**Benefits**:
+- Secure for public endpoints
+- Replay attack prevention (timestamp validation)
+- No additional infrastructure needed
+
+#### SSH Tunnel (Local Development)
+
+Localhost-only access via SSH tunnel:
+
+```bash
+# On server
+agentful serve --auth=none
+
+# On client
+ssh -L 3000:localhost:3000 your-server
+curl http://localhost:3000/agent/orchestrator -d '{"task": "..."}'
+```
+
+**Benefits**:
+- Simple setup for development
+- SSH handles authentication
+- No additional configuration
+
+### Oracle Cloud Free Tier Deployment
+
+Deploy agentful to Oracle Cloud's always-free tier: **4 ARM cores, 24GB RAM, $0/month**.
+
+#### 1. Create Oracle Cloud Account
+
+1. Sign up at [cloud.oracle.com](https://cloud.oracle.com)
+2. Navigate to **Compute** > **Instances**
+3. Click **Create Instance**
+
+#### 2. Configure Instance
+
+- **Image**: Ubuntu 22.04 LTS (ARM)
+- **Shape**: VM.Standard.A1.Flex (4 OCPUs, 24GB RAM - always free)
+- **Networking**: Create new VCN with default settings
+- **SSH Keys**: Upload your public key
+
+#### 3. Install Dependencies
+
+```bash
+# SSH into instance
+ssh ubuntu@<instance-ip>
+
+# Install Node.js 22
+curl -fsSL https://deb.nodesource.com/setup_22.x | sudo -E bash -
+sudo apt-get install -y nodejs
+
+# Install Tailscale
+curl -fsSL https://tailscale.com/install.sh | sh
+sudo tailscale up
+```
+
+#### 4. Deploy agentful
+
+```bash
+# Clone your repository
+git clone https://github.com/your-org/your-project.git
+cd your-project
+
+# Initialize agentful
+npx @itz4blitz/agentful init
+
+# Start server (runs in background)
+nohup npx agentful serve --auth=tailscale > agentful.log 2>&1 &
+```
+
+#### 5. Configure Systemd (Optional)
+
+Create `/etc/systemd/system/agentful.service`:
+
+```ini
+[Unit]
+Description=agentful agent server
+After=network.target
+
+[Service]
+Type=simple
+User=ubuntu
+WorkingDirectory=/home/ubuntu/your-project
+ExecStart=/usr/bin/npx agentful serve --auth=tailscale
+Restart=always
+RestartSec=10
+
+[Install]
+WantedBy=multi-user.target
+```
+
+Enable and start:
+
+```bash
+sudo systemctl daemon-reload
+sudo systemctl enable agentful
+sudo systemctl start agentful
+```
+
+### Configuration
+
+Server configuration in `.claude/settings.json`:
+
+```json
+{
+  "server": {
+    "port": 3000,
+    "host": "0.0.0.0",
+    "auth": "tailscale",
+    "https": {
+      "enabled": true,
+      "cert": "/path/to/cert.pem",
+      "key": "/path/to/key.pem"
+    },
+    "hmac": {
+      "secret": "${HMAC_SECRET}",
+      "timestampWindow": 300
+    }
+  }
+}
+```
+
+---
+
+## CI/CD Integration
+
+Integrate agentful with any CI/CD platform via HTTP API or workflow templates.
+
+### GitHub Actions
+
+```yaml
+name: agentful CI/CD
+on: [push, pull_request]
+
+jobs:
+  agentful:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Setup Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: 22
+
+      - name: Initialize agentful
+        run: npx @itz4blitz/agentful init
+
+      - name: Run orchestrator
+        run: |
+          npx agentful agent orchestrator \
+            --task "implement pending features" \
+            --validate
+
+      - name: Quality gates
+        run: npx agentful validate
+```
+
+### GitLab CI
+
+```yaml
+stages:
+  - setup
+  - implement
+  - validate
+
+setup:
+  stage: setup
+  script:
+    - npx @itz4blitz/agentful init
+  cache:
+    paths:
+      - .claude/
+      - node_modules/
+
+implement:
+  stage: implement
+  script:
+    - npx agentful agent orchestrator --task "implement pending features"
+  artifacts:
+    paths:
+      - .agentful/
+      - src/
+
+validate:
+  stage: validate
+  script:
+    - npx agentful validate
+  dependencies:
+    - implement
+```
+
+### Jenkins
+
+```groovy
+pipeline {
+  agent any
+
+  stages {
+    stage('Setup') {
+      steps {
+        sh 'npx @itz4blitz/agentful init'
+      }
+    }
+
+    stage('Implement') {
+      steps {
+        sh 'npx agentful agent orchestrator --task "implement pending features"'
+      }
+    }
+
+    stage('Validate') {
+      steps {
+        sh 'npx agentful validate'
+      }
+    }
+  }
+
+  post {
+    always {
+      archiveArtifacts artifacts: '.agentful/**', allowEmptyArchive: true
+    }
+  }
+}
+```
+
+### HTTP API (Any Platform)
+
+Use the REST API from any CI/CD platform:
+
+```bash
+# CircleCI, Bitbucket, Travis, etc.
+curl -X POST http://agentful-server:3000/agent/orchestrator \
+  -H "Content-Type: application/json" \
+  -H "X-Timestamp: $(date +%s)" \
+  -H "X-Signature: $SIGNATURE" \
+  -d '{
+    "task": "implement feature X",
+    "context": {
+      "branch": "'$CI_BRANCH'",
+      "commit": "'$CI_COMMIT'"
+    }
+  }'
+```
+
+**API Endpoints**:
+
+- `POST /agent/{agent-name}` - Execute agent task
+- `GET /status` - Get current state
+- `POST /validate` - Run quality gates
+- `GET /health` - Health check
+
+---
+
+## Domain-Specific Agent Generation
+
+agentful generates agents that understand YOUR codebase, not generic templates.
+
+### How It Works
+
+#### 1. Architecture Analysis
+
+The architect agent samples your codebase to detect:
+
+- **Language and framework**: TypeScript + React, Python + Django, etc.
+- **File organization**: Feature-based, layer-based, monorepo, etc.
+- **Coding conventions**: Naming patterns, import styles, formatting
+- **Error handling**: Try/catch patterns, error types, logging
+- **Testing patterns**: Framework, test structure, mocking strategies
+
+```bash
+/agentful-analyze
+```
+
+Analysis output saved to `.agentful/architecture.json`:
+
+```json
+{
+  "language": "typescript",
+  "framework": "react",
+  "patterns": {
+    "fileOrganization": "feature-based",
+    "importStyle": "named-imports",
+    "errorHandling": "custom-error-classes",
+    "testing": "jest-with-rtl"
+  },
+  "confidence": 0.85,
+  "examples": {
+    "componentStructure": "src/features/auth/LoginForm.tsx",
+    "apiClient": "src/lib/api/client.ts",
+    "errorHandling": "src/lib/errors/ApiError.ts"
+  }
+}
+```
+
+#### 2. Agent Generation Flow
+
+##### New Projects (No Code Yet)
+
+1. **Tech stack prompt**: Architect asks about your choices
+   ```
+   Frontend framework: React
+   Backend framework: Express
+   Database: PostgreSQL
+   ORM: Prisma
+   ```
+
+2. **Template-based generation**: Creates agents using best practices
+   - Based on official documentation
+   - Common patterns and conventions
+   - Marked with `confidence: 0.4`
+
+3. **First feature implementation**: System builds initial feature
+
+4. **Automatic re-analysis**: After completion
+   - Analyzes actual code patterns
+   - Updates agents with project-specific examples
+   - Confidence increases to `0.8+`
+   - Remaining features use refined agents
+
+##### Existing Projects (With Code)
+
+1. **Pattern detection**: Immediate analysis of existing code
+2. **High-confidence agents**: Real examples from your project (`0.8-1.0`)
+3. **Ready to use**: Start implementing features immediately
+
+### Generate Specialized Agents
+
+After analysis, generate domain-specific agents:
+
+```bash
+/agentful-generate
+```
+
+This creates/updates agents in `.claude/agents/` with:
+
+- **Real code examples** from YOUR project
+- **Specific patterns** matching your conventions
+- **Framework-specific guidance** for your stack
+- **Confidence scores** indicating pattern certainty
+
+Example generated agent (`.claude/agents/backend.md`):
+
+```markdown
+# Backend Agent
+
+You are the backend agent for a TypeScript Express application.
+
+## Project Architecture
+
+**Framework**: Express with TypeScript
+**Database**: PostgreSQL with Prisma ORM
+**Confidence**: 0.87
+
+## Coding Patterns
+
+### API Route Structure
+Follow the feature-based organization pattern:
+
+\`\`\`typescript
+// src/features/users/routes.ts
+import { Router } from 'express';
+import { UserController } from './controller';
+
+export const userRouter = Router();
+userRouter.post('/users', UserController.create);
+\`\`\`
+
+### Error Handling
+Use custom error classes with proper HTTP status codes:
+
+\`\`\`typescript
+// Example from: src/lib/errors/ApiError.ts
+export class ValidationError extends ApiError {
+  constructor(message: string, field?: string) {
+    super(message, 400, 'VALIDATION_ERROR', { field });
+  }
+}
+\`\`\`
+
+### Database Access
+Use Prisma client with transaction patterns:
+
+\`\`\`typescript
+// Example from: src/features/orders/service.ts
+await prisma.$transaction(async (tx) => {
+  await tx.order.create({ data: orderData });
+  await tx.inventory.update({ where: { id }, data: { quantity: { decrement: 1 } } });
+});
+\`\`\`
+```
+
+### Confidence Scores
+
+Agents include confidence scores indicating pattern detection certainty:
+
+- **0.4**: Template-based (new projects before first implementation)
+- **0.6-0.7**: Partial pattern detection (limited code samples)
+- **0.8-0.9**: Strong pattern detection (consistent patterns found)
+- **1.0**: Full confidence (comprehensive pattern analysis)
+
+### Continuous Refinement
+
+Agents improve over time:
+
+1. **After each feature**: Architect can re-analyze to update patterns
+2. **Manual refinement**: Edit generated agents in `.claude/agents/`
+3. **Version control**: Track agent evolution with your codebase
+
+---
+
+## Installation
+
+### Web Configurator
 
 Configure your agentful installation with an interactive web interface:
 
@@ -22,8 +589,6 @@ Configure your agentful installation with an interactive web interface:
 - Shareable setup URLs
 - No CLI required
 
-## Installation
-
 ### Default Installation (Recommended)
 
 Install agentful with all components - works with any tech stack:
@@ -96,6 +661,8 @@ This command:
 
 **Important**: Run `npx @itz4blitz/agentful init` only once during initial setup. For all subsequent updates, use `/agentful-update` instead of re-running init.
 
+---
+
 ## Usage
 
 ### 1. Define Product Specification
@@ -158,10 +725,10 @@ For brand new projects with no code yet:
    - Remaining features use refined, project-specific agents
 
 **Benefits**:
-- ✅ Start immediately without existing code
-- ✅ No blocking on pattern detection
-- ✅ Learns and adapts after first implementation
-- ✅ Continuously improving agent quality
+- Start immediately without existing code
+- No blocking on pattern detection
+- Learns and adapts after first implementation
+- Continuously improving agent quality
 
 #### Existing Projects (With Code)
 
@@ -185,6 +752,24 @@ For projects with existing code:
 - `/agentful-validate` - Run quality checks
 - `/agentful-decide` - Answer blocking questions
 
+---
+
+## Commands
+
+| Command | Description |
+|---------|-------------|
+| `/agentful` | Main agentful command - shows help and available commands |
+| `/agentful-product` | Smart product planning: create, analyze, and refine requirements |
+| `/agentful-start` | Start or resume structured development |
+| `/agentful-status` | Display progress and current state |
+| `/agentful-validate` | Run all quality checks |
+| `/agentful-decide` | Answer pending decisions |
+| `/agentful-update` | Smart update mechanism - fetches latest templates and gracefully migrates changes |
+| `/agentful-analyze` | Analyze architecture and generate specialized agents for your tech stack |
+| `/agentful-generate` | Generate specialized agents from architecture analysis |
+
+---
+
 ## Architecture
 
 ### Agent System
@@ -242,50 +827,7 @@ User configuration is stored in `.claude/` (version controlled):
   - `deployment/` - Deployment preparation and validation
 - `settings.json` - Project configuration
 
-## Commands
-
-| Command | Description |
-|---------|-------------|
-| `/agentful` | Main agentful command - shows help and available commands |
-| `/agentful-product` | Smart product planning: create, analyze, and refine requirements |
-| `/agentful-start` | Start or resume structured development |
-| `/agentful-status` | Display progress and current state |
-| `/agentful-validate` | Run all quality checks |
-| `/agentful-decide` | Answer pending decisions |
-| `/agentful-update` | Smart update mechanism - fetches latest templates and gracefully migrates changes |
-| `/agentful-analyze` | Analyze architecture and generate specialized agents for your tech stack |
-| `/agentful-generate` | Generate specialized agents from architecture analysis |
-
-## CI/CD Integration
-
-Run agentful agents in GitHub Actions, GitLab CI, Jenkins, or Bitbucket Pipelines.
-
-```bash
-# Generate workflow files for your CI platform
-agentful ci --generate-workflow
-
-# Or use the interactive command
-agentful ci
-```
-
-See `examples/` for sample workflow configurations ([GitHub Actions](examples/github-actions-pipeline.yml), [GitLab CI](examples/gitlab-ci-cd.yml)).
-
-## Remote Execution
-
-Run agentful agents on remote servers via secure HTTP API.
-
-```bash
-# Start server with Tailscale (most secure, recommended)
-agentful serve
-
-# Start server with HMAC authentication and HTTPS
-agentful serve --auth=hmac --secret=$SECRET --https --cert=cert.pem --key=key.pem
-
-# Start server for local SSH tunnel access
-agentful serve --auth=none
-```
-
-Three authentication modes: **Tailscale** (WireGuard encryption), **HMAC** (signature-based with replay protection), **SSH tunnel** (localhost-only).
+---
 
 ## Technology Support
 
@@ -298,15 +840,15 @@ agentful detects and adapts to your technology stack automatically:
 - **ORMs**: Prisma, Drizzle, TypeORM, Mongoose
 - **Testing**: Jest, Vitest, Playwright, Cypress, Pytest, JUnit
 
+---
+
 ## Requirements
 
 - Claude Code ([code.anthropic.com](https://code.anthropic.com))
 - Node.js 22 or higher
 - Git
 
-## Documentation
-
-Documentation: [agentful.app](https://agentful.app)
+---
 
 ## Project Structure
 
@@ -330,10 +872,20 @@ your-project/
 └── src/                            # Source code
 ```
 
+---
+
+## Documentation
+
+Full documentation: [agentful.app](https://agentful.app)
+
+---
+
 ## License
 
 MIT
 
+---
+
 ## Links
 
 - GitHub: [github.com/itz4blitz/agentful](https://github.com/itz4blitz/agentful)

package/bin/cli.js

@@ -1041,13 +1041,19 @@ async function startDaemon(args, config) {
   // Prepare args for child process (remove --daemon flag)
   const childArgs = args.filter(arg => !arg.startsWith('--daemon') && arg !== '-d');
 
+  // Create log files for daemon output
+  const logFile = path.join(agentfulDir, 'server.log');
+  const errLogFile = path.join(agentfulDir, 'server.err.log');
+  const out = fs.openSync(logFile, 'a');
+  const err = fs.openSync(errLogFile, 'a');
+
   // Spawn detached child process
   const child = spawn(
     process.argv[0], // node executable
     [process.argv[1], 'serve', ...childArgs], // script path and args
     {
       detached: true,
-      stdio: 'ignore',
+      stdio: ['ignore', out, err],
       cwd: process.cwd(),
       env: {
         ...process.env,
@@ -1056,18 +1062,40 @@ async function startDaemon(args, config) {
     }
   );
 
-  // Write PID file
-  fs.writeFileSync(pidFile, child.pid.toString(), 'utf-8');
-
-  // Unref to allow parent to exit
+  // Unref immediately to allow parent to exit independently
   child.unref();
 
+  // Wait for server to start (check health endpoint)
+  const maxAttempts = 10;
+  let started = false;
+  for (let i = 0; i < maxAttempts; i++) {
+    await new Promise(resolve => setTimeout(resolve, 500));
+    try {
+      const response = await fetch(`http://localhost:${config.port}/health`);
+      if (response.ok) {
+        started = true;
+        break;
+      }
+    } catch {
+      // Server not ready yet
+    }
+  }
+
+  if (!started) {
+    log(colors.yellow, 'Warning: Server may not have started successfully');
+    log(colors.dim, `Check logs: ${logFile}`);
+  }
+
+  // Write PID file after confirming server started
+  fs.writeFileSync(pidFile, child.pid.toString(), 'utf-8');
+
   // Show success message
   log(colors.green, `Server started in background (PID: ${child.pid})`);
   console.log('');
   log(colors.dim, `PID file: ${pidFile}`);
   log(colors.dim, `Port: ${config.port}`);
   log(colors.dim, `Auth: ${config.auth}`);
+  log(colors.dim, `Logs: ${logFile}`);
   console.log('');
   log(colors.dim, 'Commands:');
   log(colors.dim, '  agentful serve --stop     Stop the daemon');

package/lib/server/auth.js

@@ -194,24 +194,8 @@ export function createAuthMiddleware(mode, config = {}) {
       };
 
     case 'none':
-      // None mode: Only allow localhost connections
+      // None mode: Allow all connections (use with SSH tunnel for security)
       return (req, res, next) => {
-        const clientIP = req.socket.remoteAddress;
-        const isLocalhost =
-          clientIP === '127.0.0.1' ||
-          clientIP === '::1' ||
-          clientIP === '::ffff:127.0.0.1';
-
-        if (!isLocalhost) {
-          res.writeHead(403, { 'Content-Type': 'application/json' });
-          return res.end(
-            JSON.stringify({
-              error: 'Forbidden',
-              message: 'Server is in localhost-only mode. Use SSH tunnel or switch to tailscale/hmac mode.',
-            })
-          );
-        }
-
         next();
       };
 

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@itz4blitz/agentful",
-  "version": "1.0.1",
-  "description": "Human-in-the-loop development kit for Claude Code with smart product analysis and natural conversation",
+  "version": "1.1.0",
+  "description": "Pre-configured AI agent toolkit with self-hosted remote execution. Auto-generates domain specialists, supports all platforms, complete development automation.",
   "type": "module",
   "bin": {
     "agentful": "bin/cli.js"
@@ -34,10 +34,17 @@
   ],
   "keywords": [
     "claude-code",
-    "human-in-the-loop",
-    "ai-development",
-    "agent",
-    "productivity"
+    "self-hosted",
+    "agent-server",
+    "autonomous-development",
+    "code-generation",
+    "multi-platform",
+    "ai-agents",
+    "development-automation",
+    "specialized-agents",
+    "orchestrator",
+    "ci-cd",
+    "remote-execution"
   ],
   "author": "agentful",
   "license": "MIT",

package/version.json

@@ -1,3 +1,3 @@
 {
-  "version": "1.0.0"
+  "version": "1.0.2"
 }