@zweer/dev 1.0.1

package/cli/commands/cao/init.js

@@ -0,0 +1,87 @@
+import { mkdir, readFile, writeFile } from 'node:fs/promises';
+import { basename, join } from 'node:path';
+import { Command } from '@commander-js/extra-typings';
+import chalk from 'chalk';
+import inquirer from 'inquirer';
+import { paths } from '../../utils/paths.js';
+export async function createOrchestrator(config) {
+    // Read template
+    const templatePath = join(paths.templates, 'orchestrator.md');
+    let template = await readFile(templatePath, 'utf-8');
+    // Replace placeholders
+    template = template
+        .replace(/\{\{PROJECT_NAME\}\}/g, config.projectName)
+        .replace(/\{\{PROJECT_PATH\}\}/g, config.projectPath)
+        .replace(/\{\{TECH_STACK\}\}/g, config.techStack)
+        .replace(/\{\{PROJECT_STRUCTURE\}\}/g, config.projectStructure);
+    // Create .cao/agents directory
+    const caoDir = join(config.projectPath, '.cao', 'agents');
+    await mkdir(caoDir, { recursive: true });
+    // Write orchestrator file
+    const orchestratorPath = join(caoDir, `${config.name}.md`);
+    await writeFile(orchestratorPath, template);
+    return { orchestratorPath };
+}
+export function getDefaultConfig(cwd, name) {
+    const projectName = basename(cwd);
+    return {
+        name: name || `${projectName}_orchestrator`,
+        projectName,
+        projectPath: cwd,
+        techStack: 'Next.js, TypeScript, PostgreSQL',
+        projectStructure: 'app/, components/, lib/',
+    };
+}
+export const initCommand = new Command()
+    .name('init')
+    .description('Create orchestrator in current project')
+    .argument('[name]', 'Orchestrator name')
+    .option('-y, --yes', 'Skip prompts and use defaults')
+    .action(async (name, options) => {
+    const cwd = process.cwd();
+    let config = getDefaultConfig(cwd, name);
+    if (!options.yes) {
+        const answers = await inquirer.prompt([
+            {
+                type: 'input',
+                name: 'name',
+                message: 'Orchestrator name:',
+                default: config.name,
+            },
+            {
+                type: 'input',
+                name: 'projectName',
+                message: 'Project name:',
+                default: config.projectName,
+            },
+            {
+                type: 'input',
+                name: 'techStack',
+                message: 'Tech stack:',
+                default: config.techStack,
+            },
+            {
+                type: 'input',
+                name: 'projectStructure',
+                message: 'Main folders:',
+                default: config.projectStructure,
+            },
+        ]);
+        config = { ...config, ...answers };
+    }
+    console.log(chalk.cyan(`\n🎯 Creating orchestrator: ${config.name}\n`));
+    try {
+        const { orchestratorPath } = await createOrchestrator(config);
+        console.log(chalk.green(`✅ Orchestrator created: ${orchestratorPath}\n`));
+        console.log(chalk.gray('Next steps:'));
+        console.log(chalk.gray('  1. Edit the orchestrator to add project-specific details'));
+        console.log(chalk.gray('  2. Run: dev install'));
+        console.log(chalk.gray(`  3. Run: cao launch --agents ${config.name}`));
+        console.log();
+    }
+    catch (error) {
+        console.error(chalk.red('Failed to create orchestrator'));
+        console.error(error);
+        process.exit(1);
+    }
+});

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

@@ -0,0 +1,10 @@
+import { Command } from '@commander-js/extra-typings';
+export declare function executeInstallCao(): Promise<void>;
+export declare function executeInstallAgents(): Promise<{
+    installed: number;
+    failed: number;
+}>;
+export declare const installCommand: Command<[], {
+    caoOnly?: true | undefined;
+    agentsOnly?: true | undefined;
+}>;

package/cli/commands/cao/install.js

@@ -0,0 +1,58 @@
+import { Command } from '@commander-js/extra-typings';
+import chalk from 'chalk';
+import ora from 'ora';
+import { getAllAgents } from '../../utils/agents.js';
+import { installAgent, installCao } from '../../utils/cao.js';
+export async function executeInstallCao() {
+    await installCao();
+}
+export async function executeInstallAgents() {
+    const agents = await getAllAgents();
+    let installed = 0;
+    let failed = 0;
+    for (const agent of agents) {
+        try {
+            await installAgent(agent.path);
+            installed++;
+        }
+        catch {
+            failed++;
+        }
+    }
+    return { installed, failed };
+}
+export const installCommand = new Command()
+    .name('install')
+    .description('Install CAO and all common agents')
+    .option('--cao-only', 'Install only CAO')
+    .option('--agents-only', 'Install only agents')
+    .action(async (options) => {
+    const installCaoOnly = options.caoOnly;
+    const installAgentsOnly = options.agentsOnly;
+    // Install CAO
+    if (!installAgentsOnly) {
+        const spinner = ora('Installing CAO prerequisites...').start();
+        try {
+            await executeInstallCao();
+            spinner.succeed(chalk.green('CAO installed successfully'));
+        }
+        catch (error) {
+            spinner.fail(chalk.red('Failed to install CAO'));
+            console.error(error);
+            process.exit(1);
+        }
+    }
+    // Install agents
+    if (!installCaoOnly) {
+        const agents = await getAllAgents();
+        const spinner = ora(`Installing ${agents.length} agents...`).start();
+        const { installed, failed } = await executeInstallAgents();
+        if (failed === 0) {
+            spinner.succeed(chalk.green(`All ${installed} agents installed successfully`));
+        }
+        else {
+            spinner.warn(chalk.yellow(`Installed ${installed} agents, ${failed} failed`));
+        }
+    }
+    console.log(chalk.bold.green('\n✅ Installation complete!\n'));
+});

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

@@ -0,0 +1,3 @@
+import { Command } from '@commander-js/extra-typings';
+export declare function executeLaunch(agentName: string): Promise<void>;
+export declare const launchCommand: Command<[string], {}>;

package/cli/commands/cao/launch.js

@@ -0,0 +1,21 @@
+import { Command } from '@commander-js/extra-typings';
+import chalk from 'chalk';
+import { launchAgent } from '../../utils/cao.js';
+export async function executeLaunch(agentName) {
+    await launchAgent(agentName);
+}
+export const launchCommand = new Command()
+    .name('launch')
+    .description('Launch a specific agent')
+    .argument('<agent>', 'Agent name to launch')
+    .action(async (agentName) => {
+    console.log(chalk.cyan(`🚀 Launching ${agentName}...\n`));
+    try {
+        await executeLaunch(agentName);
+    }
+    catch (error) {
+        console.error(chalk.red(`Failed to launch ${agentName}`));
+        console.error(error);
+        process.exit(1);
+    }
+});

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

@@ -0,0 +1,4 @@
+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<[], {}>;

package/cli/commands/cao/list.js

@@ -0,0 +1,28 @@
+import { Command } from '@commander-js/extra-typings';
+import chalk from 'chalk';
+import { getAllAgents } from '../../utils/agents.js';
+export function groupAgentsByCategory(agents) {
+    return agents.reduce((acc, agent) => {
+        const key = agent.subcategory ? `${agent.category}/${agent.subcategory}` : agent.category;
+        if (!acc[key])
+            acc[key] = [];
+        acc[key].push(agent);
+        return acc;
+    }, {});
+}
+export const listCommand = new Command()
+    .name('list')
+    .description('List all available agents')
+    .action(async () => {
+    const agents = await getAllAgents();
+    console.log(chalk.bold('\n📦 Available Agents:\n'));
+    const grouped = groupAgentsByCategory(agents);
+    for (const [category, categoryAgents] of Object.entries(grouped)) {
+        console.log(chalk.cyan(`\n${category}:`));
+        for (const agent of categoryAgents) {
+            const desc = agent.description ? chalk.gray(` - ${agent.description}`) : '';
+            console.log(`  ${chalk.green(agent.name)}${desc}`);
+        }
+    }
+    console.log(chalk.gray(`\nTotal: ${agents.length} agents\n`));
+});

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

@@ -0,0 +1,3 @@
+import { Command } from '@commander-js/extra-typings';
+export declare function executeServer(): Promise<void>;
+export declare const serverCommand: Command<[], {}>;

package/cli/commands/cao/server.js

@@ -0,0 +1,20 @@
+import { Command } from '@commander-js/extra-typings';
+import chalk from 'chalk';
+import { startServer } from '../../utils/cao.js';
+export async function executeServer() {
+    await startServer();
+}
+export const serverCommand = new Command()
+    .name('server')
+    .description('Launch the CAO server')
+    .action(async () => {
+    console.log(chalk.cyan('🚀 Starting CAO server...\n'));
+    try {
+        await executeServer();
+    }
+    catch (error) {
+        console.error(chalk.red('Failed to start server'));
+        console.error(error);
+        process.exit(1);
+    }
+});

package/cli/commands/setup.d.ts

@@ -0,0 +1,4 @@
+import { Command } from '@commander-js/extra-typings';
+export declare const setup: Command<[], {
+    yes?: true | undefined;
+}>;

package/cli/commands/setup.js

@@ -0,0 +1,269 @@
+import { exec } from 'node:child_process';
+import { access, mkdir, readFile, writeFile } from 'node:fs/promises';
+import { promisify } from 'node:util';
+import { Command } from '@commander-js/extra-typings';
+import chalk from 'chalk';
+import inquirer from 'inquirer';
+import ora from 'ora';
+const execAsync = promisify(exec);
+const DEV_DEPENDENCIES = {
+    '@biomejs/biome': '^2.3.4',
+    '@semantic-release/changelog': '^6.0.3',
+    '@semantic-release/git': '^10.0.1',
+    '@tsconfig/node22': '^22.0.2',
+    '@types/node': '^24.10.0',
+    '@vitest/coverage-v8': '^4.0.8',
+    concurrently: '^9.2.1',
+    husky: '^9.1.7',
+    'lint-staged': '^16.2.6',
+    'lockfile-lint': '^4.14.1',
+    'ls-engines': '^0.9.3',
+    publint: '^0.3.15',
+    rimraf: '^6.1.0',
+    'semantic-release': '^25.0.2',
+    typescript: '^5.9.3',
+    vitest: '^4.0.8',
+};
+const SCRIPTS = {
+    lint: 'concurrently npm:lint:* --prefixColors auto',
+    'lint:format': 'biome check --write',
+    'lint:lockfile': 'lockfile-lint --path package-lock.json',
+    'lint:engines': 'ls-engines',
+    'lint:publish': 'publint --strict',
+    test: 'vitest run',
+    'test:coverage': 'vitest run --coverage',
+    check: 'npm run clean && npm run test:coverage && npm run build && npm run lint && npm run clean',
+    prepare: 'husky',
+    clean: 'rimraf --glob ./{src,test}/**/*.{d.ts,js} ./vitest*.{d.ts,js}',
+    prebuild: 'npm run clean',
+    build: 'tsc',
+    release: 'semantic-release',
+};
+async function fileExists(path) {
+    try {
+        await access(path);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export const setup = new Command()
+    .name('setup')
+    .description('Add standard configuration to an existing project')
+    .option('-y, --yes', 'Skip prompts and use defaults')
+    .action(async (options) => {
+    const answers = options.yes
+        ? { configs: ['all'] }
+        : await inquirer.prompt([
+            {
+                type: 'checkbox',
+                name: 'configs',
+                message: 'Select configurations to add:',
+                choices: [
+                    { name: 'All', value: 'all', checked: true },
+                    { name: 'TypeScript (tsconfig.json)', value: 'typescript' },
+                    { name: 'Biome (biome.json)', value: 'biome' },
+                    { name: 'Vitest (vitest.config.ts)', value: 'vitest' },
+                    { name: 'Lint-staged (.lintstagedrc)', value: 'lintstaged' },
+                    { name: 'EditorConfig (.editorconfig)', value: 'editorconfig' },
+                    { name: 'Husky (.husky/pre-commit)', value: 'husky' },
+                    { name: 'Dependencies', value: 'deps' },
+                    { name: 'Scripts', value: 'scripts' },
+                ],
+            },
+        ]);
+    const selected = answers.configs.includes('all')
+        ? ['typescript', 'biome', 'vitest', 'lintstaged', 'editorconfig', 'husky', 'deps', 'scripts']
+        : answers.configs;
+    const spinner = ora('Setting up project...').start();
+    try {
+        // Update package.json
+        if (selected.includes('deps') || selected.includes('scripts')) {
+            const pkgPath = 'package.json';
+            if (!(await fileExists(pkgPath))) {
+                spinner.fail(chalk.red('package.json not found. Run this in a project directory.'));
+                process.exit(1);
+            }
+            const pkgContent = await readFile(pkgPath, 'utf-8');
+            const pkg = JSON.parse(pkgContent);
+            if (selected.includes('deps')) {
+                spinner.text = 'Adding dependencies...';
+                pkg.devDependencies = { ...pkg.devDependencies, ...DEV_DEPENDENCIES };
+            }
+            if (selected.includes('scripts')) {
+                spinner.text = 'Adding scripts...';
+                pkg.scripts = { ...pkg.scripts, ...SCRIPTS };
+                if (!pkg.engines) {
+                    pkg.engines = { node: '>= 20.17' };
+                }
+                if (!pkg.publishConfig) {
+                    pkg.publishConfig = { access: 'public', provenance: true };
+                }
+                if (!pkg.release) {
+                    pkg.release = {
+                        plugins: [
+                            '@semantic-release/commit-analyzer',
+                            '@semantic-release/release-notes-generator',
+                            '@semantic-release/changelog',
+                            '@semantic-release/npm',
+                            '@semantic-release/github',
+                            '@semantic-release/git',
+                        ],
+                    };
+                }
+            }
+            await writeFile(pkgPath, JSON.stringify(pkg, null, 2));
+        }
+        // TypeScript
+        if (selected.includes('typescript') && !(await fileExists('tsconfig.json'))) {
+            spinner.text = 'Creating tsconfig.json...';
+            const tsconfig = {
+                extends: '@tsconfig/node22/tsconfig.json',
+                compilerOptions: {
+                    declaration: true,
+                    skipLibCheck: true,
+                },
+            };
+            await writeFile('tsconfig.json', JSON.stringify(tsconfig, null, 2));
+        }
+        // Biome
+        if (selected.includes('biome') && !(await fileExists('biome.json'))) {
+            spinner.text = 'Creating biome.json...';
+            const biome = {
+                $schema: 'https://biomejs.dev/schemas/2.3.4/schema.json',
+                vcs: { enabled: true, clientKind: 'git', useIgnoreFile: true },
+                files: { ignoreUnknown: false },
+                formatter: { enabled: true, useEditorconfig: true, lineWidth: 100 },
+                linter: {
+                    enabled: true,
+                    rules: { recommended: true, suspicious: { noUnknownAtRules: 'off' } },
+                    domains: { test: 'recommended' },
+                },
+                javascript: { formatter: { quoteStyle: 'single' } },
+                assist: {
+                    enabled: true,
+                    actions: {
+                        source: {
+                            organizeImports: {
+                                level: 'on',
+                                options: {
+                                    groups: [
+                                        ':URL:',
+                                        ':BLANK_LINE:',
+                                        [':BUN:', ':NODE:'],
+                                        ':BLANK_LINE:',
+                                        [':PACKAGE_WITH_PROTOCOL:', ':PACKAGE:'],
+                                        ':BLANK_LINE:',
+                                        ':ALIAS:',
+                                        ':BLANK_LINE:',
+                                        ':PATH:',
+                                    ],
+                                },
+                            },
+                        },
+                    },
+                },
+            };
+            await writeFile('biome.json', JSON.stringify(biome, null, 2));
+        }
+        // Vitest
+        if (selected.includes('vitest') && !(await fileExists('vitest.config.ts'))) {
+            spinner.text = 'Creating vitest.config.ts...';
+            const vitestConfig = `import { defineConfig } from 'vitest/config';
+
+export default defineConfig({
+  test: {
+    globals: true,
+    environment: 'node',
+  },
+});
+`;
+            await writeFile('vitest.config.ts', vitestConfig);
+        }
+        // Lint-staged
+        if (selected.includes('lintstaged') && !(await fileExists('.lintstagedrc'))) {
+            spinner.text = 'Creating .lintstagedrc...';
+            const lintStaged = `"*.{ts,tsx}":
+  - "bash -c 'npm test'"
+
+"package.json":
+  - "bash -c 'npm test'"
+  - "bash -c 'npm run build'"
+  - "bash -c 'npm run lint:lockfile'"
+  - "bash -c 'npm run lint:engines'"
+  - "bash -c 'npm run lint:publish'"
+  - "bash -c 'npm run clean'"
+
+"*.{ts,tsx,json,yaml,graphql,md,css,scss,html}":
+  - "biome check --write --no-errors-on-unmatched --files-ignore-unknown=true"
+`;
+            await writeFile('.lintstagedrc', lintStaged);
+        }
+        // EditorConfig
+        if (selected.includes('editorconfig') && !(await fileExists('.editorconfig'))) {
+            spinner.text = 'Creating .editorconfig...';
+            const editorconfig = `# http://editorconfig.org/
+root = true
+
+[*]
+charset = utf-8
+end_of_line = lf
+insert_final_newline = true
+indent_style = space
+indent_size = 2
+trim_trailing_whitespace = true
+
+[*.md]
+trim_trailing_whitespace = false
+
+[Makefile]
+indent_style = tab
+`;
+            await writeFile('.editorconfig', editorconfig);
+        }
+        // Husky
+        if (selected.includes('husky')) {
+            spinner.text = 'Creating .husky/pre-commit...';
+            await mkdir('.husky', { recursive: true });
+            if (!(await fileExists('.husky/pre-commit'))) {
+                const preCommit = `export NVM_DIR="$HOME/.nvm"
+[ -s "$NVM_DIR/nvm.sh" ] && \\. "$NVM_DIR/nvm.sh"
+
+lint-staged --concurrent false
+git update-index --again
+`;
+                await writeFile('.husky/pre-commit', preCommit);
+                await execAsync('chmod +x .husky/pre-commit');
+            }
+        }
+        // Install dependencies
+        if (selected.includes('deps')) {
+            spinner.text = 'Installing dependencies...';
+            await execAsync('npm install');
+        }
+        spinner.succeed(chalk.green('✓ Project setup complete!'));
+        console.log('\nAdded configurations:');
+        if (selected.includes('typescript'))
+            console.log(chalk.cyan('  ✓ tsconfig.json'));
+        if (selected.includes('biome'))
+            console.log(chalk.cyan('  ✓ biome.json'));
+        if (selected.includes('vitest'))
+            console.log(chalk.cyan('  ✓ vitest.config.ts'));
+        if (selected.includes('lintstaged'))
+            console.log(chalk.cyan('  ✓ .lintstagedrc'));
+        if (selected.includes('editorconfig'))
+            console.log(chalk.cyan('  ✓ .editorconfig'));
+        if (selected.includes('husky'))
+            console.log(chalk.cyan('  ✓ .husky/pre-commit'));
+        if (selected.includes('deps'))
+            console.log(chalk.cyan('  ✓ Dependencies'));
+        if (selected.includes('scripts'))
+            console.log(chalk.cyan('  ✓ Scripts'));
+    }
+    catch (error) {
+        spinner.fail(chalk.red('Failed to setup project'));
+        console.error(error);
+        process.exit(1);
+    }
+});

package/cli/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/cli/index.js

@@ -0,0 +1,13 @@
+#!/usr/bin/env node
+import { Command } from '@commander-js/extra-typings';
+import { bootstrap } from './commands/bootstrap.js';
+import { caoCommand } from './commands/cao/index.js';
+import { setup } from './commands/setup.js';
+const program = new Command()
+    .name('dev')
+    .description('Shared configurations & AI agents for software projects')
+    .version('0.1.0');
+program.addCommand(bootstrap);
+program.addCommand(setup);
+program.addCommand(caoCommand);
+program.parse();

package/cli/utils/agents.d.ts

@@ -0,0 +1,8 @@
+export interface Agent {
+    name: string;
+    path: string;
+    category: string;
+    subcategory?: string;
+    description?: string;
+}
+export declare function getAllAgents(): Promise<Agent[]>;

package/cli/utils/agents.js

@@ -0,0 +1,55 @@
+import { readdir, readFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { paths } from './paths.js';
+export async function getAllAgents() {
+    const agents = [];
+    const categories = await readdir(paths.agents, { withFileTypes: true });
+    for (const category of categories) {
+        if (!category.isDirectory())
+            continue;
+        const categoryPath = join(paths.agents, category.name);
+        const items = await readdir(categoryPath, { withFileTypes: true });
+        for (const item of items) {
+            if (item.isDirectory()) {
+                // Subcategory (es: web/frontend)
+                const subcategoryPath = join(categoryPath, item.name);
+                const files = await readdir(subcategoryPath);
+                for (const file of files) {
+                    if (file.endsWith('.md')) {
+                        const agentPath = join(subcategoryPath, file);
+                        const description = await extractDescription(agentPath);
+                        agents.push({
+                            name: file.replace('.md', ''),
+                            path: agentPath,
+                            category: category.name,
+                            subcategory: item.name,
+                            description,
+                        });
+                    }
+                }
+            }
+            else if (item.name.endsWith('.md')) {
+                // Direct agent file (es: data/data_engineer.md)
+                const agentPath = join(categoryPath, item.name);
+                const description = await extractDescription(agentPath);
+                agents.push({
+                    name: item.name.replace('.md', ''),
+                    path: agentPath,
+                    category: category.name,
+                    description,
+                });
+            }
+        }
+    }
+    return agents;
+}
+async function extractDescription(agentPath) {
+    try {
+        const content = await readFile(agentPath, 'utf-8');
+        const match = content.match(/^description:\s*["']?(.+?)["']?$/m);
+        return match?.[1];
+    }
+    catch {
+        return undefined;
+    }
+}

package/cli/utils/cao.d.ts

@@ -0,0 +1,8 @@
+export declare function runCommand(command: string): Promise<{
+    stdout: string;
+    stderr: string;
+}>;
+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>;

package/cli/utils/cao.js

@@ -0,0 +1,23 @@
+import { exec } from 'node:child_process';
+import { promisify } from 'node:util';
+const execAsync = promisify(exec);
+export async function runCommand(command) {
+    return execAsync(command);
+}
+export async function installCao() {
+    // Install tmux config
+    await runCommand('curl -s https://raw.githubusercontent.com/awslabs/cli-agent-orchestrator/refs/heads/main/tmux-install.sh -o /tmp/tmux-install.sh && bash /tmp/tmux-install.sh || true');
+    // Install uv
+    await runCommand('curl -LsSf https://astral.sh/uv/install.sh | sh');
+    // Install CAO
+    await runCommand('uv tool install git+https://github.com/awslabs/cli-agent-orchestrator.git@main --upgrade');
+}
+export async function installAgent(agentPath) {
+    await runCommand(`cao install "${agentPath}"`);
+}
+export async function launchAgent(agentName) {
+    await runCommand(`cao launch --agents ${agentName}`);
+}
+export async function startServer() {
+    await runCommand('cao-server');
+}

package/cli/utils/paths.d.ts

@@ -0,0 +1,5 @@
+export declare const paths: {
+    root: string;
+    agents: string;
+    templates: string;
+};

package/cli/utils/paths.js

@@ -0,0 +1,11 @@
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+export const paths = {
+    // Root del pacchetto @zweer/dev
+    root: join(__dirname, '../..'),
+    // Cartelle del pacchetto
+    agents: join(__dirname, '../../agents'),
+    templates: join(__dirname, '../../templates'),
+};