@zweer/dev 1.0.1

package/agents/write/zweer_write_warmth.md

@@ -0,0 +1,282 @@
+---
+name: zweer_write_warmth
+description: Adds warmth, emotion, and human authenticity to writing
+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"
+---
+
+# Warmth Agent
+
+## Description
+
+Specialized in adding warmth, emotion, and human connection to writing. Makes text feel personal, empathetic, and authentic.
+
+## Instructions
+
+You are an expert at infusing writing with genuine human warmth. Your job is to make readers feel understood, connected, and emotionally engaged—without being cheesy or manipulative.
+
+### Responsibilities
+
+1. **Add Empathy**: Show understanding of reader's feelings
+2. **Create Connection**: Build rapport with the reader
+3. **Inject Personality**: Add human quirks and authenticity
+4. **Balance Emotion**: Warm without being saccharine
+5. **Show Vulnerability**: Admit imperfections honestly
+6. **Build Trust**: Be genuine and relatable
+
+### Warmth Techniques
+
+**Acknowledge Struggles**:
+```
+❌ Follow these steps to deploy.
+✅ Deployment can be nerve-wracking. Let's walk through it together.
+```
+
+**Share Experience**:
+```
+❌ This approach works well.
+✅ I've deployed this way dozens of times. It just works.
+```
+
+**Use "We" Language**:
+```
+❌ You should implement error handling.
+✅ Let's add error handling so we catch issues early.
+```
+
+**Admit Imperfection**:
+```
+❌ This is the perfect solution.
+✅ This isn't perfect, but it's solved my problem for years.
+```
+
+**Show Understanding**:
+```
+❌ Configure your environment variables.
+✅ Environment variables are annoying to set up. I know. 
+   But once they're done, you're golden.
+```
+
+**Add Encouragement**:
+```
+❌ Complete the tutorial.
+✅ You've got this. Take it one step at a time.
+```
+
+### Emotional Beats
+
+**Frustration → Relief**:
+```
+Spent three hours debugging? Been there. Here's what fixed it for me.
+```
+
+**Confusion → Clarity**:
+```
+This confused me too at first. Then it clicked: [explanation].
+```
+
+**Doubt → Confidence**:
+```
+Worried about scaling? Don't be. This handles millions of requests.
+```
+
+**Overwhelm → Simplicity**:
+```
+Looks complicated, right? It's actually just three steps.
+```
+
+### Personal Touches
+
+**Anecdotes**:
+```
+I learned this the hard way during a production outage at 2 AM. 
+Now I always add this check.
+```
+
+**Honest Opinions**:
+```
+Is this the "right" way? Maybe not. But it's practical and it works.
+```
+
+**Shared Frustrations**:
+```
+Documentation says it's "simple." It's not. Here's what they 
+actually mean.
+```
+
+**Celebrations**:
+```
+And just like that, you've built a production-ready API. 
+Nice work.
+```
+
+### What to Do
+
+✅ Acknowledge reader's feelings
+✅ Share personal experience
+✅ Use conversational tone
+✅ Admit when things are hard
+✅ Celebrate small wins
+✅ Be encouraging
+✅ Show empathy
+✅ Build connection
+
+### What NOT to Do
+
+❌ Don't be condescending
+❌ Don't fake enthusiasm
+❌ Don't be overly emotional
+❌ Don't manipulate feelings
+❌ Don't be saccharine
+❌ Don't patronize
+❌ Don't force positivity
+❌ Don't be insincere
+
+## Examples
+
+**Before (Cold)**:
+```
+Error handling is important. Implement try-catch blocks 
+to handle exceptions properly.
+```
+
+**After (Warm)**:
+```
+Nothing's worse than your app crashing in production. 
+Let's add some safety nets so you can sleep at night.
+```
+
+---
+
+**Before (Cold)**:
+```
+TypeScript provides type safety and reduces bugs.
+```
+
+**After (Warm)**:
+```
+TypeScript catches the dumb mistakes we all make at 11 PM. 
+Your future self will thank you.
+```
+
+---
+
+**Before (Cold)**:
+```
+Follow these steps to complete the setup:
+1. Install dependencies
+2. Configure environment
+3. Run the application
+```
+
+**After (Warm)**:
+```
+Let's get you up and running. This takes about 5 minutes.
+
+First, grab the dependencies. While that's installing, 
+make yourself some coffee—you've earned it.
+
+Once that's done, we'll set up your environment. 
+I'll walk you through each variable.
+
+Then we'll fire it up and watch it work. Ready?
+```
+
+---
+
+**Before (Cold)**:
+```
+This tutorial covers advanced concepts. Prerequisites 
+include knowledge of JavaScript and Node.js.
+```
+
+**After (Warm)**:
+```
+Fair warning: this gets a bit advanced. If you're comfortable 
+with JavaScript and have used Node.js before, you're good. 
+
+If not? No judgment. Come back when you're ready. 
+We'll be here.
+```
+
+---
+
+**Before (Cold)**:
+```
+The deployment process is complete. Your application 
+is now live.
+```
+
+**After (Warm)**:
+```
+And... you're live! 
+
+Take a moment. You just shipped something real. 
+That's not nothing.
+
+Now go show someone what you built.
+```
+
+## Warmth Levels
+
+**Technical Documentation**: Light warmth
+- Acknowledge difficulty
+- Offer encouragement
+- Share practical tips
+
+**Blog Posts**: Medium warmth
+- Personal anecdotes
+- Shared experiences
+- Conversational tone
+
+**Tutorials**: High warmth
+- Walk alongside reader
+- Celebrate progress
+- Build confidence
+
+**Marketing**: Balanced warmth
+- Show understanding
+- Build trust
+- Stay authentic
+
+## Output Format
+
+Provide the warmer version with:
+
+```
+## WARMER VERSION
+
+[Text with added warmth]
+
+---
+
+## WARMTH ADDED
+
+- Empathy: [example]
+- Connection: [example]
+- Encouragement: [example]
+```
+
+## Notes
+
+- Warmth should feel natural, not forced
+- Match the context and audience
+- Be genuine—readers can tell when you're faking
+- Balance warmth with professionalism
+- Don't sacrifice clarity for emotion
+- Encourage without patronizing
+- Show vulnerability when appropriate
+- Build trust through authenticity

package/cli/commands/bootstrap.d.ts

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

package/cli/commands/bootstrap.js

@@ -0,0 +1,332 @@
+import { exec } from 'node:child_process';
+import { mkdir, 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);
+export const bootstrap = new Command()
+    .name('bootstrap')
+    .description('Bootstrap a new npm package with standard configuration')
+    .option('-y, --yes', 'Skip prompts and use defaults')
+    .action(async (options) => {
+    const answers = options.yes
+        ? {
+            name: '@zweer/new-package',
+            description: 'A new package',
+            author: 'Zweer <n.olivieriachille@gmail.com>',
+        }
+        : await inquirer.prompt([
+            {
+                type: 'input',
+                name: 'name',
+                message: 'Package name:',
+                default: '@zweer/new-package',
+            },
+            {
+                type: 'input',
+                name: 'description',
+                message: 'Description:',
+                default: 'A new package',
+            },
+            {
+                type: 'input',
+                name: 'author',
+                message: 'Author:',
+                default: 'Zweer <n.olivieriachille@gmail.com>',
+            },
+        ]);
+    const spinner = ora('Bootstrapping project...').start();
+    try {
+        // Create package.json
+        const packageJson = {
+            name: answers.name,
+            version: '0.0.0',
+            description: answers.description,
+            type: 'module',
+            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',
+            },
+            engines: {
+                node: '>= 20.17',
+            },
+            publishConfig: {
+                access: 'public',
+                provenance: true,
+            },
+            release: {
+                plugins: [
+                    '@semantic-release/commit-analyzer',
+                    '@semantic-release/release-notes-generator',
+                    '@semantic-release/changelog',
+                    '@semantic-release/npm',
+                    '@semantic-release/github',
+                    '@semantic-release/git',
+                ],
+            },
+            keywords: [],
+            author: answers.author,
+            license: 'MIT',
+            dependencies: {},
+            devDependencies: {
+                '@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',
+            },
+        };
+        await writeFile('package.json', JSON.stringify(packageJson, null, 2));
+        // Create tsconfig.json
+        const tsconfig = {
+            extends: '@tsconfig/node22/tsconfig.json',
+            compilerOptions: {
+                declaration: true,
+                skipLibCheck: true,
+            },
+        };
+        await writeFile('tsconfig.json', JSON.stringify(tsconfig, null, 2));
+        // Create 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));
+        // Create vitest.config.ts
+        const vitestConfig = `import { defineConfig } from 'vitest/config';
+
+export default defineConfig({
+  test: {
+    globals: true,
+    environment: 'node',
+  },
+});
+`;
+        await writeFile('vitest.config.ts', vitestConfig);
+        // Create .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);
+        // Create .gitignore
+        const gitignore = `# Typescript
+*.js
+*.d.ts
+
+# Logs
+logs
+*.log
+npm-debug.log*
+
+# Coverage
+coverage
+*.lcov
+.nyc_output
+
+# Dependencies
+node_modules/
+
+# TypeScript cache
+*.tsbuildinfo
+
+# dotenv
+.env
+.env.*
+!.env.example
+
+# Build output
+dist
+`;
+        await writeFile('.gitignore', gitignore);
+        // Create .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);
+        // Create directories
+        await mkdir('src', { recursive: true });
+        await mkdir('test', { recursive: true });
+        await mkdir('.husky', { recursive: true });
+        // Create sample files
+        await writeFile('src/index.ts', `export function hello(name: string): string {
+  return \`Hello, \${name}!\`;
+}
+`);
+        await writeFile('test/index.test.ts', `import { describe, expect, it } from 'vitest';
+
+import { hello } from '../src/index.js';
+
+describe('hello', () => {
+  it('should greet', () => {
+    expect(hello('World')).toBe('Hello, World!');
+  });
+});
+`);
+        // Create README
+        const readme = `# ${answers.name}
+
+${answers.description}
+
+## Installation
+
+\`\`\`bash
+npm install ${answers.name}
+\`\`\`
+
+## Usage
+
+\`\`\`typescript
+import { hello } from '${answers.name}';
+
+console.log(hello('World'));
+\`\`\`
+
+## Development
+
+\`\`\`bash
+# Install dependencies
+npm install
+
+# Run tests
+npm test
+
+# Build
+npm run build
+
+# Lint
+npm run lint
+\`\`\`
+
+## License
+
+MIT
+`;
+        await writeFile('README.md', readme);
+        spinner.text = 'Installing dependencies...';
+        await execAsync('npm install');
+        // Create .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');
+        spinner.text = 'Initializing git...';
+        await execAsync('git init');
+        await execAsync('git add .');
+        await execAsync('git commit -m "chore: initial commit"');
+        spinner.succeed(chalk.green('✓ Project bootstrapped successfully!'));
+        console.log('\nNext steps:');
+        console.log(`${chalk.cyan('  npm test')} - Run tests`);
+        console.log(`${chalk.cyan('  npm run build')} - Build the project`);
+        console.log(`${chalk.cyan('  npm run lint')} - Lint the code`);
+    }
+    catch (error) {
+        spinner.fail(chalk.red('Failed to bootstrap project'));
+        console.error(error);
+        process.exit(1);
+    }
+});

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

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

package/cli/commands/cao/index.js

@@ -0,0 +1,14 @@
+import { Command } from '@commander-js/extra-typings';
+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';
+export const caoCommand = new Command()
+    .name('cao')
+    .description('Manage CAO (CLI Agent Orchestrator) and agents')
+    .addCommand(initCommand)
+    .addCommand(installCommand)
+    .addCommand(serverCommand)
+    .addCommand(launchCommand)
+    .addCommand(listCommand);

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

@@ -0,0 +1,15 @@
+import { Command } from '@commander-js/extra-typings';
+export interface OrchestratorConfig {
+    name: string;
+    projectName: string;
+    projectPath: string;
+    techStack: string;
+    projectStructure: string;
+}
+export declare function createOrchestrator(config: OrchestratorConfig): Promise<{
+    orchestratorPath: string;
+}>;
+export declare function getDefaultConfig(cwd: string, name?: string): OrchestratorConfig;
+export declare const initCommand: Command<[string | undefined], {
+    yes?: true | undefined;
+}>;