@dyyz1993/create-agent 1.9.0

package/package.json

@@ -0,0 +1,25 @@
+{
+  "name": "@dyyz1993/create-agent",
+  "version": "1.9.0",
+  "description": "Create Agent project scaffolding CLI",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/dyyz1993/pi-agent-template"
+  },
+  "bin": {
+    "create-agent": "./src/cli.ts"
+  },
+  "files": [
+    "src/",
+    "templates/"
+  ],
+  "scripts": {
+    "sync-templates": "rm -rf templates/general templates/chat templates/agent && rsync -a --exclude='node_modules' --exclude='dist' --exclude='build' --exclude='.server-port' --exclude='logs' --exclude='bun.lock' ../../templates/general/ templates/general/ && rsync -a --exclude='node_modules' --exclude='dist' --exclude='build' --exclude='.server-port' --exclude='logs' --exclude='bun.lock' ../../templates/chat/ templates/chat/ && rsync -a --exclude='node_modules' --exclude='dist' --exclude='build' --exclude='.server-port' --exclude='logs' --exclude='bun.lock' ../../templates/agent/ templates/agent/ && rsync -a ../../packages/eslint-plugin-rpc/ templates/agent/eslint-plugin-rpc/ && rsync -a ../../packages/eslint-plugin-rpc/ templates/chat/eslint-plugin-rpc/ && rsync -a ../../packages/eslint-plugin-rpc/ templates/general/eslint-plugin-rpc/ && node scripts/post-sync-templates.mjs",
+    "test": "bun test src/__tests__/",
+    "prepublishOnly": "test -d templates/general/src && test -d templates/chat/src && test -d templates/agent/src"
+  },
+  "engines": {
+    "bun": ">=1.0.0"
+  },
+  "license": "MIT"
+}

package/src/__tests__/cli.test.ts

@@ -0,0 +1,85 @@
+import { describe, test, expect, spyOn } from 'bun:test';
+import { runCreate } from '../commands/create';
+import { runList } from '../commands/list';
+
+describe('CLI argument parsing (create)', () => {
+  test('runCreate exits without project name', async () => {
+    const mockExit = spyOn(process, 'exit').mockImplementation(() => {
+      throw new Error('process.exit');
+    });
+    const mockLog = spyOn(console, 'log').mockImplementation(() => {});
+
+    try {
+      await runCreate([]);
+    } catch (e: unknown) {
+      expect((e as Error).message).toBe('process.exit');
+    }
+
+    expect(mockExit).toHaveBeenCalledWith(1);
+    mockExit.mockRestore();
+    mockLog.mockRestore();
+  });
+
+  test('runCreate throws for invalid --type', async () => {
+    expect(runCreate(['my-app', '--type', 'nonexistent'])).rejects.toThrow(
+      'Unknown template type',
+    );
+  });
+
+  test('runCreate shows usage in help output', async () => {
+    const mockExit = spyOn(process, 'exit').mockImplementation(() => {
+      throw new Error('process.exit');
+    });
+    const logs: string[] = [];
+    const mockLog = spyOn(console, 'log').mockImplementation((...args: unknown[]) => {
+      logs.push(args.join(' '));
+    });
+
+    try {
+      await runCreate([]);
+    } catch {
+      // expected
+    }
+
+    const output = logs.join('\n');
+    expect(output).toContain('create-agent create');
+    expect(output).toContain('--type');
+    expect(output).toContain('--dir');
+
+    mockExit.mockRestore();
+    mockLog.mockRestore();
+  });
+});
+
+describe('CLI argument parsing (list)', () => {
+  test('runList outputs all template types', async () => {
+    const logs: string[] = [];
+    const mockLog = spyOn(console, 'log').mockImplementation((...args: unknown[]) => {
+      logs.push(args.join(' '));
+    });
+
+    await runList();
+
+    const output = logs.join('\n');
+    expect(output).toContain('general');
+    expect(output).toContain('chat');
+    expect(output).toContain('agent');
+    expect(output).toContain('Available templates');
+
+    mockLog.mockRestore();
+  });
+});
+
+describe('CLI command registry', () => {
+  test('all 4 commands are importable', async () => {
+    const { runCreate } = await import('../commands/create');
+    const { runList } = await import('../commands/list');
+    const { runStatus } = await import('../commands/status');
+    const { runWorkspace } = await import('../commands/workspace');
+
+    expect(typeof runCreate).toBe('function');
+    expect(typeof runList).toBe('function');
+    expect(typeof runStatus).toBe('function');
+    expect(typeof runWorkspace).toBe('function');
+  });
+});

package/src/__tests__/copy.test.ts

@@ -0,0 +1,168 @@
+import { describe, test, expect, afterAll } from 'bun:test';
+import { mkdtempSync, mkdirSync, writeFileSync, existsSync, readFileSync, rmSync } from 'fs';
+import { join } from 'path';
+import { tmpdir } from 'os';
+import { copyAndReplace, deriveNames } from '../lib/copy';
+
+const TMP_DIRS: string[] = [];
+
+afterAll(() => {
+  for (const d of TMP_DIRS) {
+    if (existsSync(d)) rmSync(d, { recursive: true, force: true });
+  }
+});
+
+function makeTmp(prefix = 'pi-cli-test-'): string {
+  const d = mkdtempSync(join(tmpdir(), prefix));
+  TMP_DIRS.push(d);
+  return d;
+}
+
+describe('deriveNames', () => {
+  test('simple name', () => {
+    const names = deriveNames('my-app');
+    expect(names.pascalName).toBe('MyApp');
+    expect(names.identifier).toBe('com.myapp.app');
+    expect(names.shortId).toBe('com.myapp');
+  });
+
+  test('single word', () => {
+    const names = deriveNames('hello');
+    expect(names.pascalName).toBe('Hello');
+    expect(names.identifier).toBe('com.hello.app');
+    expect(names.shortId).toBe('com.hello');
+  });
+
+  test('multi-segment name', () => {
+    const names = deriveNames('my-cool-project');
+    expect(names.pascalName).toBe('MyCoolProject');
+    expect(names.identifier).toBe('com.mycoolproject.app');
+    expect(names.shortId).toBe('com.mycoolproject');
+  });
+});
+
+describe('copyAndReplace', () => {
+  test('copies files from src to dest', () => {
+    const srcDir = makeTmp('pi-src-');
+    const destDir = makeTmp('pi-dest-');
+
+    writeFileSync(join(srcDir, 'hello.txt'), 'hello world');
+
+    copyAndReplace(srcDir, destDir, 'test-project');
+
+    expect(existsSync(join(destDir, 'hello.txt'))).toBe(true);
+    expect(readFileSync(join(destDir, 'hello.txt'), 'utf-8')).toBe('hello world');
+  });
+
+  test('replaces pi-agent-template with project name', () => {
+    const srcDir = makeTmp('pi-src-');
+    const destDir = makeTmp('pi-dest-');
+
+    writeFileSync(join(srcDir, 'config.json'), '{"name": "pi-agent-template"}');
+
+    copyAndReplace(srcDir, destDir, 'my-app');
+
+    const content = readFileSync(join(destDir, 'config.json'), 'utf-8');
+    expect(content).toBe('{"name": "my-app"}');
+  });
+
+  test('replaces Pi Agent Template with pascal name', () => {
+    const srcDir = makeTmp('pi-src-');
+    const destDir = makeTmp('pi-dest-');
+
+    writeFileSync(join(srcDir, 'readme.md'), '# Pi Agent Template');
+
+    copyAndReplace(srcDir, destDir, 'my-app');
+
+    const content = readFileSync(join(destDir, 'readme.md'), 'utf-8');
+    expect(content).toBe('# MyApp');
+  });
+
+  test('replaces Pi Agent with pascal name', () => {
+    const srcDir = makeTmp('pi-src-');
+    const destDir = makeTmp('pi-dest-');
+
+    writeFileSync(join(srcDir, 'app.ts'), 'export const Pi Agent = true');
+
+    copyAndReplace(srcDir, destDir, 'cool-project');
+
+    const content = readFileSync(join(destDir, 'app.ts'), 'utf-8');
+    expect(content).toBe('export const CoolProject = true');
+  });
+
+  test('replaces com.piagent.template with identifier', () => {
+    const srcDir = makeTmp('pi-src-');
+    const destDir = makeTmp('pi-dest-');
+
+    writeFileSync(join(srcDir, 'plist.xml'), '<string>com.piagent.template</string>');
+
+    copyAndReplace(srcDir, destDir, 'my-app');
+
+    const content = readFileSync(join(destDir, 'plist.xml'), 'utf-8');
+    expect(content).toBe('<string>com.myapp.app</string>');
+  });
+
+  test('replaces com.piagent with shortId', () => {
+    const srcDir = makeTmp('pi-src-');
+    const destDir = makeTmp('pi-dest-');
+
+    writeFileSync(join(srcDir, 'config.xml'), '<id>com.piagent.something</id>');
+
+    copyAndReplace(srcDir, destDir, 'my-app');
+
+    const content = readFileSync(join(destDir, 'config.xml'), 'utf-8');
+    expect(content).toBe('<id>com.myapp.something</id>');
+  });
+
+  test('replaces @pi-agent/ scope', () => {
+    const srcDir = makeTmp('pi-src-');
+    const destDir = makeTmp('pi-dest-');
+
+    writeFileSync(join(srcDir, 'pkg.json'), '"@pi-agent/rpc-core"');
+
+    copyAndReplace(srcDir, destDir, 'my-app');
+
+    const content = readFileSync(join(destDir, 'pkg.json'), 'utf-8');
+    expect(content).toBe('"@my-app/rpc-core"');
+  });
+
+  test('skips node_modules directory', () => {
+    const srcDir = makeTmp('pi-src-');
+    const destDir = makeTmp('pi-dest-');
+
+    mkdirSync(join(srcDir, 'node_modules', 'pkg'), { recursive: true });
+    writeFileSync(join(srcDir, 'node_modules', 'pkg', 'index.js'), 'module.exports = 1;');
+    writeFileSync(join(srcDir, 'root.txt'), 'root');
+
+    copyAndReplace(srcDir, destDir, 'test');
+
+    expect(existsSync(join(destDir, 'root.txt'))).toBe(true);
+    expect(existsSync(join(destDir, 'node_modules'))).toBe(false);
+  });
+
+  test('skips bun.lock file', () => {
+    const srcDir = makeTmp('pi-src-');
+    const destDir = makeTmp('pi-dest-');
+
+    writeFileSync(join(srcDir, 'bun.lock'), 'lockfile content');
+    writeFileSync(join(srcDir, 'package.json'), '{}');
+
+    copyAndReplace(srcDir, destDir, 'test');
+
+    expect(existsSync(join(destDir, 'package.json'))).toBe(true);
+    expect(existsSync(join(destDir, 'bun.lock'))).toBe(false);
+  });
+
+  test('copies nested directories recursively', () => {
+    const srcDir = makeTmp('pi-src-');
+    const destDir = makeTmp('pi-dest-');
+
+    mkdirSync(join(srcDir, 'src', 'lib'), { recursive: true });
+    writeFileSync(join(srcDir, 'src', 'lib', 'util.ts'), '// pi-agent-template util');
+
+    copyAndReplace(srcDir, destDir, 'my-proj');
+
+    const content = readFileSync(join(destDir, 'src', 'lib', 'util.ts'), 'utf-8');
+    expect(content).toBe('// my-proj util');
+  });
+});

package/src/__tests__/templates.test.ts

@@ -0,0 +1,87 @@
+import { describe, test, expect } from 'bun:test';
+import { getAllTemplates, getTemplateInfo, resolveTemplateDir } from '../lib/templates';
+
+describe('getAllTemplates', () => {
+  test('returns 3 templates', () => {
+    const templates = getAllTemplates();
+    expect(templates).toHaveLength(3);
+  });
+
+  test('includes general, chat, agent types', () => {
+    const templates = getAllTemplates();
+    const types = templates.map((t) => t.type);
+    expect(types).toContain('general');
+    expect(types).toContain('chat');
+    expect(types).toContain('agent');
+  });
+
+  test('all templates are available', () => {
+    const templates = getAllTemplates();
+    for (const t of templates) {
+      expect(t.available).toBe(true);
+    }
+  });
+
+  test('each template has required fields', () => {
+    const templates = getAllTemplates();
+    for (const t of templates) {
+      expect(t.type).toBeTruthy();
+      expect(t.description).toBeTruthy();
+      expect(t.dir).toBeTruthy();
+      expect(typeof t.available).toBe('boolean');
+    }
+  });
+});
+
+describe('getTemplateInfo', () => {
+  test('returns info for "general"', () => {
+    const info = getTemplateInfo('general');
+    expect(info).toBeDefined();
+    expect(info!.type).toBe('general');
+    expect(info!.dir).toBe('templates/general');
+  });
+
+  test('returns info for "chat"', () => {
+    const info = getTemplateInfo('chat');
+    expect(info).toBeDefined();
+    expect(info!.type).toBe('chat');
+  });
+
+  test('returns info for "agent"', () => {
+    const info = getTemplateInfo('agent');
+    expect(info).toBeDefined();
+    expect(info!.type).toBe('agent');
+  });
+
+  test('returns undefined for unknown type', () => {
+    expect(getTemplateInfo('nonexistent')).toBeUndefined();
+    expect(getTemplateInfo('')).toBeUndefined();
+  });
+});
+
+describe('resolveTemplateDir', () => {
+  test('resolves general template path', () => {
+    const dir = resolveTemplateDir('/fake/root', 'general');
+    expect(dir).toBe('/fake/root/templates/general');
+  });
+
+  test('resolves chat template path', () => {
+    const dir = resolveTemplateDir('/fake/root', 'chat');
+    expect(dir).toBe('/fake/root/templates/chat');
+  });
+
+  test('resolves agent template path', () => {
+    const dir = resolveTemplateDir('/fake/root', 'agent');
+    expect(dir).toBe('/fake/root/templates/agent');
+  });
+
+  test('throws for invalid template type', () => {
+    expect(() => resolveTemplateDir('/root', 'invalid')).toThrow(
+      'Unknown template type: "invalid"',
+    );
+  });
+
+  test('throws with empty string', () => {
+    expect(() => resolveTemplateDir('/root', '')).toThrow('Unknown template type');
+  });
+});

package/src/cli.ts

@@ -0,0 +1,65 @@
+#!/usr/bin/env bun
+
+import { runCreate } from './commands/create.js';
+import { runList } from './commands/list.js';
+import { runStatus } from './commands/status.js';
+import { runWorkspace } from './commands/workspace.js';
+
+const COMMANDS = new Map<string, (args: string[]) => Promise<void>>([
+  ['create', runCreate],
+  ['list', runList],
+  ['status', runStatus],
+  ['workspace', runWorkspace],
+]);
+
+function printHelp(): void {
+  console.log(`
+Create Agent CLI — project scaffolding tool
+
+Usage:
+  create-agent <command> [options]
+
+Commands:
+  create <name>  Create a new project from template
+  list           Show available template types
+  status         Show active pi-agent instances
+  workspace add <name>  Create isolated workspace for parallel development
+  update         Update project to latest template (coming soon)
+
+Options:
+  -h, --help     Show this help message
+
+Run "create-agent create --help" for create-specific options.
+`);
+}
+
+async function main(): Promise<void> {
+  const args = process.argv.slice(2);
+
+  const command = args[0];
+  const rest = args.slice(1);
+
+  if (!command || command === '-h' || command === '--help') {
+    printHelp();
+    process.exit(0);
+  }
+
+  if (command === 'update') {
+    console.log('Update feature coming soon');
+    return;
+  }
+
+  const handler = COMMANDS.get(command);
+  if (!handler) {
+    console.error(`Unknown command: "${command}"\n`);
+    printHelp();
+    process.exit(1);
+  }
+
+  await handler(rest);
+}
+
+main().catch((err) => {
+  console.error(`Error: ${err.message}`);
+  process.exit(1);
+});

package/src/commands/create.ts

@@ -0,0 +1,49 @@
+import { resolve } from 'path';
+import { resolveTemplateDir, getRootDir } from '../lib/templates.js';
+import { copyTemplate } from '../lib/copy.js';
+
+export async function runCreate(args: string[]): Promise<void> {
+  let templateType = 'general';
+  let customDir: string | undefined;
+
+  const positional: string[] = [];
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg === '--type' && args[i + 1]) {
+      templateType = args[++i];
+    } else if (arg === '--dir' && args[i + 1]) {
+      customDir = args[++i];
+    } else if (!arg.startsWith('--')) {
+      positional.push(arg);
+    }
+  }
+
+  const projectName = positional[0];
+  const targetArg = customDir || positional[1];
+  if (!projectName) {
+    console.log(`
+Usage: create-agent create <name> [--type <type>] [--dir <path>]
+
+Options:
+  --type <type>   Template type (default: general)
+  --dir <path>    Target directory (default: ./<name>)
+
+Examples:
+  create-agent create my-app
+  create-agent create my-app --type chat
+  create-agent create my-app --dir ~/projects/my-app
+`);
+    process.exit(1);
+  }
+
+  const sanitized = projectName.replace(/[^a-zA-Z0-9-_]/g, '-');
+  const targetDir = targetArg ? resolve(targetArg) : resolve(process.cwd(), sanitized);
+  const rootDir = getRootDir();
+  const templateDir = resolveTemplateDir(rootDir, templateType);
+
+  await copyTemplate({
+    projectName: sanitized,
+    templateDir,
+    targetDir,
+  });
+}

package/src/commands/list.ts

@@ -0,0 +1,12 @@
+import { getAllTemplates } from '../lib/templates.js';
+
+export async function runList(): Promise<void> {
+  const templates = getAllTemplates();
+
+  console.log('Available templates:\n');
+  for (const t of templates) {
+    const suffix = t.available ? '' : ' (coming soon)';
+    console.log(`  ${t.type.padEnd(10)} ${t.description}${suffix}`);
+  }
+  console.log('');
+}

package/src/commands/status.ts

@@ -0,0 +1,85 @@
+import { readFileSync, existsSync, writeFileSync } from 'fs';
+import { resolve } from 'path';
+import type { PortEntry } from '../lib/types.js';
+
+function isPidAlive(pid: number): boolean {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function getUptime(startedAt: string): string {
+  const start = new Date(startedAt).getTime();
+  if (isNaN(start)) return 'unknown';
+  const diff = Date.now() - start;
+  const minutes = Math.floor(diff / 60000);
+  if (minutes < 1) return '<1m';
+  if (minutes < 60) return `${minutes}m`;
+  const hours = Math.floor(minutes / 60);
+  const remMinutes = minutes % 60;
+  if (hours < 24) return `${hours}h ${remMinutes}m`;
+  const days = Math.floor(hours / 24);
+  const remHours = hours % 24;
+  return `${days}d ${remHours}h`;
+}
+
+export async function runStatus(): Promise<void> {
+  const registryPath = resolve(process.env.HOME || '~', '.pi-agent', 'ports.json');
+
+  if (!existsSync(registryPath)) {
+    console.log('No active instances.\n');
+    return;
+  }
+
+  let registry: Record<string, PortEntry>;
+  try {
+    const raw = readFileSync(registryPath, 'utf-8');
+    const parsed = JSON.parse(raw);
+    if (Array.isArray(parsed)) {
+      registry = {};
+      for (const entry of parsed) {
+        const key = entry.dir || entry.name || String(entry.port);
+        registry[key] = entry;
+      }
+    } else {
+      registry = parsed;
+    }
+  } catch {
+    console.log('No active instances.\n');
+    return;
+  }
+
+  const allEntries = Object.entries(registry);
+  if (allEntries.length === 0) {
+    console.log('No active instances.\n');
+    return;
+  }
+
+  const aliveEntries = allEntries.filter(([, e]) => isPidAlive(e.pid));
+  const cleaned = aliveEntries.length < allEntries.length;
+
+  if (cleaned) {
+    const cleanedRegistry: Record<string, PortEntry> = {};
+    for (const [key, entry] of aliveEntries) {
+      cleanedRegistry[key] = entry;
+    }
+    writeFileSync(registryPath, JSON.stringify(cleanedRegistry, null, 2) + '\n');
+  }
+
+  if (aliveEntries.length === 0) {
+    console.log('No active instances.\n');
+    return;
+  }
+
+  console.log('Active pi-agent instances:\n');
+  for (const [dir, entry] of aliveEntries) {
+    const uptime = getUptime(entry.startedAt);
+    console.log(`  ${entry.name.padEnd(16)} →  http://localhost:${entry.port}  (PID ${entry.pid}, up ${uptime})`);
+    console.log(`  ${dir}`);
+    console.log('');
+  }
+  console.log(`Registry: ${registryPath}\n`);
+}