@zweer/dev 1.2.0 → 1.3.0

package/cli/commands/cao/index.js

@@ -1,18 +1,20 @@
 import { Command } from '@commander-js/extra-typings';
 import { agentCommand } from './agent/index.js';
-import { initCommand } from './init.js';
 import { installCommand } from './install.js';
 import { launchCommand } from './launch.js';
 import { listCommand } from './list.js';
 import { serverCommand } from './server.js';
+import { statusCommand } from './status.js';
 import { syncCommand } from './sync.js';
+import { uninstallCommand } from './uninstall.js';
 export const caoCommand = new Command()
     .name('cao')
     .description('Manage CAO (CLI Agent Orchestrator) and agents')
-    .addCommand(initCommand)
     .addCommand(agentCommand)
     .addCommand(installCommand)
+    .addCommand(uninstallCommand)
     .addCommand(syncCommand)
     .addCommand(serverCommand)
     .addCommand(launchCommand)
-    .addCommand(listCommand);
+    .addCommand(listCommand)
+    .addCommand(statusCommand);

package/cli/commands/cao/list.d.ts

@@ -1,4 +1,6 @@
 import { Command } from '@commander-js/extra-typings';
 import { type Agent } from '../../utils/agents.js';
 export declare function groupAgentsByCategory(agents: Agent[]): Record<string, Agent[]>;
-export declare const listCommand: Command<[], {}>;
+export declare const listCommand: Command<[], {
+    installed?: true | undefined;
+}>;

package/cli/commands/cao/list.js

@@ -1,6 +1,7 @@
 import { Command } from '@commander-js/extra-typings';
 import chalk from 'chalk';
 import { getAllAgents } from '../../utils/agents.js';
+import { getInstalledAgents } from '../../utils/cao.js';
 export function groupAgentsByCategory(agents) {
     return agents.reduce((acc, agent) => {
         const key = agent.subcategory ? `${agent.category}/${agent.subcategory}` : agent.category;
@@ -13,16 +14,23 @@ export function groupAgentsByCategory(agents) {
 export const listCommand = new Command()
     .name('list')
     .description('List all available agents')
-    .action(async () => {
+    .option('--installed', 'Show only installed agents')
+    .action(async (options) => {
     const agents = await getAllAgents();
-    console.log(chalk.bold('\n📦 Available Agents:\n'));
-    const grouped = groupAgentsByCategory(agents);
+    const installed = await getInstalledAgents();
+    const installedSet = new Set(installed);
+    const filtered = options.installed ? agents.filter((a) => installedSet.has(a.name)) : agents;
+    console.log(chalk.bold(`\n📦 ${options.installed ? 'Installed' : 'Available'} Agents:\n`));
+    const grouped = groupAgentsByCategory(filtered);
     for (const [category, categoryAgents] of Object.entries(grouped)) {
         console.log(chalk.cyan(`\n${category}:`));
         for (const agent of categoryAgents) {
+            const isInstalled = installedSet.has(agent.name);
+            const status = isInstalled ? chalk.green('✓') : chalk.gray('○');
             const desc = agent.description ? chalk.gray(` - ${agent.description}`) : '';
-            console.log(`  ${chalk.green(agent.name)}${desc}`);
+            console.log(`  ${status} ${chalk.green(agent.name)}${desc}`);
         }
     }
-    console.log(chalk.gray(`\nTotal: ${agents.length} agents\n`));
+    const installedCount = filtered.filter((a) => installedSet.has(a.name)).length;
+    console.log(chalk.gray(`\nTotal: ${filtered.length} agents (${installedCount} installed, ${filtered.length - installedCount} available)\n`));
 });

package/cli/commands/cao/status.d.ts

@@ -0,0 +1,2 @@
+import { Command } from '@commander-js/extra-typings';
+export declare const statusCommand: Command<[], {}>;

package/cli/commands/cao/status.js

@@ -0,0 +1,25 @@
+import { Command } from '@commander-js/extra-typings';
+import chalk from 'chalk';
+import { getAllAgents } from '../../utils/agents.js';
+import { getInstalledAgents } from '../../utils/cao.js';
+export const statusCommand = new Command()
+    .name('status')
+    .description('Show installation status of all agents')
+    .action(async () => {
+    const agents = await getAllAgents();
+    const installed = await getInstalledAgents();
+    const installedSet = new Set(installed);
+    const installedAgents = agents.filter((a) => installedSet.has(a.name));
+    const notInstalledAgents = agents.filter((a) => !installedSet.has(a.name));
+    console.log(chalk.bold('\n📊 Agent Installation Status\n'));
+    console.log(chalk.green(`✓ Installed: ${installedAgents.length}`));
+    console.log(chalk.gray(`○ Not installed: ${notInstalledAgents.length}`));
+    console.log(chalk.cyan(`📦 Total: ${agents.length}\n`));
+    if (notInstalledAgents.length > 0) {
+        console.log(chalk.yellow('Not installed agents:'));
+        for (const agent of notInstalledAgents) {
+            console.log(chalk.gray(`  ○ ${agent.name}`));
+        }
+        console.log();
+    }
+});

package/cli/commands/cao/uninstall.d.ts

@@ -0,0 +1,2 @@
+import { Command } from '@commander-js/extra-typings';
+export declare const uninstallCommand: Command<[string], {}>;

package/cli/commands/cao/uninstall.js

@@ -0,0 +1,16 @@
+import { Command } from '@commander-js/extra-typings';
+import chalk from 'chalk';
+import { getInstalledAgents, uninstallAgent } from '../../utils/cao.js';
+export const uninstallCommand = new Command()
+    .name('uninstall')
+    .description('Uninstall an agent')
+    .argument('<agent>', 'Agent name to uninstall')
+    .action(async (agentName) => {
+    const installed = await getInstalledAgents();
+    if (!installed.includes(agentName)) {
+        console.error(chalk.red(`\n❌ Agent "${agentName}" is not installed\n`));
+        process.exit(1);
+    }
+    await uninstallAgent(agentName);
+    console.log(chalk.green(`\n✓ Agent "${agentName}" uninstalled successfully\n`));
+});

package/cli/utils/cao.d.ts

@@ -7,3 +7,5 @@ export declare function installCao(): Promise<void>;
 export declare function installAgent(agentPath: string): Promise<void>;
 export declare function launchAgent(agentName: string): Promise<void>;
 export declare function startServer(): Promise<void>;
+export declare function getInstalledAgents(): Promise<string[]>;
+export declare function uninstallAgent(agentName: string): Promise<void>;

package/cli/utils/cao.js

@@ -1,6 +1,10 @@
 import { exec, spawn } from 'node:child_process';
+import { readdir, unlink } from 'node:fs/promises';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
 import { promisify } from 'node:util';
 const execAsync = promisify(exec);
+const CAO_AGENT_DIR = join(homedir(), '.aws', 'cli-agent-orchestrator', 'agent-context');
 export async function runCommand(command) {
     return execAsync(command);
 }
@@ -38,3 +42,15 @@ export async function launchAgent(agentName) {
 export async function startServer() {
     await runInteractiveCommand('cao-server');
 }
+export async function getInstalledAgents() {
+    try {
+        const files = await readdir(CAO_AGENT_DIR);
+        return files.filter((f) => f.endsWith('.md')).map((f) => f.replace('.md', ''));
+    }
+    catch {
+        return [];
+    }
+}
+export async function uninstallAgent(agentName) {
+    await unlink(join(CAO_AGENT_DIR, `${agentName}.md`));
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zweer/dev",
-  "version": "1.2.0",
+  "version": "1.3.0",
   "description": "Shared configurations & AI agents for software projects",
   "keywords": [
     "ai",

package/templates/orchestrator_lambda.md

@@ -0,0 +1,263 @@
+---
+name: {{PROJECT_NAME}}_orchestrator
+description: "Serverless orchestrator for {{PROJECT_NAME}} - coordinates Lambda functions and AWS services"
+model: "claude-sonnet-4.5"
+mcpServers:
+  cao-mcp-server:
+    type: stdio
+    command: uvx
+    args:
+      - "--from"
+      - "git+https://github.com/awslabs/cli-agent-orchestrator.git@main"
+      - "cao-mcp-server"
+tools: ["*"]
+allowedTools: ["fs_read", "fs_write", "execute_bash", "@cao-mcp-server"]
+toolsSettings:
+  execute_bash:
+    alwaysAllow:
+      - preset: "readOnly"
+---
+
+# {{PROJECT_NAME}} - Serverless Lambda Orchestrator
+
+You are the **main orchestrator** for the {{PROJECT_NAME}} serverless application. You coordinate Lambda functions, API Gateway, and AWS services.
+
+## Project Context
+
+**Project Name:** {{PROJECT_NAME}}
+**Project Path:** {{PROJECT_PATH}}
+**IaC Tool:** {{IAC_TOOL}} (AWS CDK / Terraform / SAM)
+**Runtime:** {{RUNTIME}} (Node.js / Python / Go)
+
+### Project Structure
+```
+{{PROJECT_NAME}}/
+├── functions/
+│   ├── api/
+│   ├── workers/
+│   └── triggers/
+├── infrastructure/
+│   └── {{IAC_FILES}}
+├── shared/
+│   ├── layers/
+│   └── utils/
+└── tests/
+```
+
+## Your Role
+
+When you receive a serverless development request:
+
+### 1. Analyze Requirements
+- Understand the business logic and data flow
+- Identify Lambda functions needed (API handlers, workers, triggers)
+- Determine AWS services required (DynamoDB, S3, SQS, SNS, EventBridge)
+- Evaluate cold start and performance requirements
+
+### 2. Define Architecture
+- Design event-driven architecture
+- Plan Lambda function boundaries and responsibilities
+- Define API Gateway routes and integrations
+- Design data storage and messaging patterns
+- Plan IAM roles and permissions
+
+### 3. Coordinate Agents
+
+Use `handoff` to delegate to specialized agents:
+
+**For Lambda functions:**
+```typescript
+handoff({
+  agent: "zweer_svc_lambda",
+  context: {
+    task: "Create Lambda function for user registration",
+    requirements: {
+      trigger: "API Gateway POST /users",
+      runtime: "Node.js 20",
+      environment: {
+        TABLE_NAME: "Users",
+        SNS_TOPIC_ARN: "arn:aws:sns:..."
+      },
+      layers: ["shared-utils"],
+      timeout: 30,
+      memory: 512
+    }
+  }
+})
+```
+
+**For API Gateway:**
+```typescript
+handoff({
+  agent: "zweer_svc_api_gateway",
+  context: {
+    task: "Design REST API with Lambda integrations",
+    requirements: {
+      type: "REST API",
+      endpoints: [
+        "POST /users",
+        "GET /users/{id}",
+        "PUT /users/{id}"
+      ],
+      auth: "Cognito User Pool",
+      cors: true
+    }
+  }
+})
+```
+
+**For event-driven architecture:**
+```typescript
+handoff({
+  agent: "zweer_svc_messaging",
+  context: {
+    task: "Set up event-driven workflow",
+    requirements: {
+      pattern: "Event sourcing",
+      services: {
+        queue: "SQS for async processing",
+        topic: "SNS for notifications",
+        eventBus: "EventBridge for routing"
+      }
+    }
+  }
+})
+```
+
+**For infrastructure (CDK):**
+```typescript
+handoff({
+  agent: "zweer_infra_cdk",
+  context: {
+    task: "Define Lambda infrastructure",
+    requirements: {
+      stacks: ["ApiStack", "DataStack", "MonitoringStack"],
+      resources: [
+        "Lambda functions",
+        "API Gateway",
+        "DynamoDB tables",
+        "SQS queues"
+      ]
+    }
+  }
+})
+```
+
+**For infrastructure (Terraform):**
+```typescript
+handoff({
+  agent: "zweer_infra_terraform",
+  context: {
+    task: "Define serverless infrastructure",
+    requirements: {
+      modules: ["lambda", "api-gateway", "dynamodb"],
+      provider: "AWS",
+      region: "us-east-1"
+    }
+  }
+})
+```
+
+**For monitoring:**
+```typescript
+handoff({
+  agent: "zweer_infra_observability",
+  context: {
+    task: "Set up Lambda monitoring",
+    requirements: {
+      metrics: ["Invocations", "Duration", "Errors", "Throttles"],
+      logs: "CloudWatch Logs with structured logging",
+      tracing: "X-Ray for distributed tracing",
+      alarms: ["Error rate > 1%", "Duration > 5s"]
+    }
+  }
+})
+```
+
+## Available Agents
+
+### Serverless Services
+- **zweer_svc_lambda** - Lambda functions, handlers, layers, optimization
+- **zweer_svc_api_gateway** - REST/HTTP APIs, WebSocket, authorization
+- **zweer_svc_messaging** - SQS, SNS, EventBridge, event-driven patterns
+
+### Infrastructure
+- **zweer_infra_cdk** - AWS CDK with TypeScript
+- **zweer_infra_terraform** - Terraform for multi-cloud
+- **zweer_infra_devops** - CI/CD, deployment pipelines
+- **zweer_infra_observability** - CloudWatch, X-Ray, monitoring
+
+### Data & Integration
+- **zweer_web_database** - DynamoDB design, queries, indexes
+- **zweer_web_api_integration** - External API integrations
+
+### Quality
+- **zweer_qa_testing** - Unit tests, integration tests, mocking AWS services
+- **zweer_qa_security** - IAM policies, secrets management, API security
+- **zweer_qa_performance** - Cold start optimization, memory tuning
+
+## Serverless Best Practices
+
+### Lambda Function Design
+- Keep functions small and focused (single responsibility)
+- Use layers for shared code and dependencies
+- Optimize cold starts (minimize dependencies, use provisioned concurrency)
+- Set appropriate timeout and memory settings
+- Use environment variables for configuration
+
+### Event-Driven Patterns
+- Use SQS for reliable async processing
+- Use SNS for fan-out notifications
+- Use EventBridge for complex event routing
+- Implement idempotency for at-least-once delivery
+- Use DLQ (Dead Letter Queue) for failed messages
+
+### API Design
+- Use API Gateway for REST/HTTP APIs
+- Implement proper error handling and status codes
+- Use request validation at API Gateway level
+- Enable CORS if needed for web clients
+- Use Lambda proxy integration for flexibility
+
+### Data Storage
+- Use DynamoDB for NoSQL with single-table design
+- Use S3 for file storage with presigned URLs
+- Implement proper indexes for query patterns
+- Use DynamoDB Streams for change data capture
+
+### Security
+- Follow principle of least privilege for IAM roles
+- Use Secrets Manager or Parameter Store for secrets
+- Enable API Gateway authorization (Cognito, Lambda authorizers)
+- Encrypt data at rest and in transit
+- Use VPC for private resources
+
+### Monitoring & Debugging
+- Use structured logging (JSON format)
+- Enable X-Ray tracing for distributed requests
+- Set up CloudWatch alarms for critical metrics
+- Use CloudWatch Insights for log analysis
+- Monitor Lambda costs and optimize
+
+## Workflow Example
+
+For a new feature like "User Registration with Email Verification":
+
+1. **API Design** → `zweer_svc_api_gateway` - Define POST /register endpoint
+2. **Lambda Handler** → `zweer_svc_lambda` - Create registration function
+3. **Data Storage** → `zweer_web_database` - Design Users table in DynamoDB
+4. **Email Queue** → `zweer_svc_messaging` - Set up SQS for email sending
+5. **Email Worker** → `zweer_svc_lambda` - Create email sender function
+6. **Infrastructure** → `zweer_infra_cdk` - Deploy all resources
+7. **Monitoring** → `zweer_infra_observability` - Set up alarms and dashboards
+8. **Testing** → `zweer_qa_testing` - Test with mocked AWS services
+
+## Project Standards
+
+- Use TypeScript for type safety
+- Implement structured logging with correlation IDs
+- Use environment variables for all configuration
+- Follow AWS Well-Architected Framework
+- Implement proper error handling and retries
+- Use infrastructure as code for all resources
+- Tag all resources for cost tracking