@deimoscloud/coreai 0.1.0

package/src/cli/commands/init.ts

@@ -0,0 +1,296 @@
+/**
+ * Init Command
+ *
+ * Initializes a new CoreAI project with configuration file and directory structure.
+ */
+
+import { existsSync, writeFileSync, mkdirSync, readFileSync } from 'fs';
+import { join, basename } from 'path';
+import { execSync } from 'child_process';
+import type { ProjectType, GitProvider } from '../../config/types.js';
+import { configExists } from '../../config/loader.js';
+
+/**
+ * Options for init command
+ */
+export interface InitCommandOptions {
+  /**
+   * Project root directory
+   */
+  projectRoot?: string;
+
+  /**
+   * Overwrite existing configuration
+   */
+  force?: boolean;
+
+  /**
+   * Skip interactive prompts
+   */
+  nonInteractive?: boolean;
+
+  /**
+   * Project name (for non-interactive mode)
+   */
+  name?: string;
+
+  /**
+   * Project type (for non-interactive mode)
+   */
+  type?: ProjectType;
+
+  /**
+   * Skip creating directory structure
+   */
+  skipDirs?: boolean;
+}
+
+/**
+ * Result of init command
+ */
+export interface InitCommandResult {
+  success: boolean;
+  configPath?: string;
+  createdDirs?: string[];
+  error?: string;
+  gitInfo?: {
+    provider?: GitProvider;
+    owner?: string;
+    repo?: string;
+  };
+}
+
+/**
+ * Detect git remote information
+ */
+function detectGitInfo(): { provider?: GitProvider; owner?: string; repo?: string } | null {
+  try {
+    const remoteUrl = execSync('git remote get-url origin', { encoding: 'utf-8' }).trim();
+
+    // GitHub HTTPS: https://github.com/owner/repo.git
+    const httpsMatch = remoteUrl.match(/https:\/\/github\.com\/([^/]+)\/([^/.]+)/);
+    if (httpsMatch) {
+      return { provider: 'github', owner: httpsMatch[1], repo: httpsMatch[2] };
+    }
+
+    // GitHub SSH: git@github.com:owner/repo.git
+    const sshMatch = remoteUrl.match(/git@github\.com:([^/]+)\/([^/.]+)/);
+    if (sshMatch) {
+      return { provider: 'github', owner: sshMatch[1], repo: sshMatch[2] };
+    }
+
+    // GitLab HTTPS
+    const gitlabHttps = remoteUrl.match(/https:\/\/gitlab\.com\/([^/]+)\/([^/.]+)/);
+    if (gitlabHttps) {
+      return { provider: 'gitlab', owner: gitlabHttps[1], repo: gitlabHttps[2] };
+    }
+
+    // GitLab SSH
+    const gitlabSsh = remoteUrl.match(/git@gitlab\.com:([^/]+)\/([^/.]+)/);
+    if (gitlabSsh) {
+      return { provider: 'gitlab', owner: gitlabSsh[1], repo: gitlabSsh[2] };
+    }
+
+    return null;
+  } catch {
+    // Not a git repo or no remote
+    return null;
+  }
+}
+
+/**
+ * Detect project name from directory or package.json
+ */
+function detectProjectName(projectRoot: string): string {
+  // Try package.json first
+  const packageJsonPath = join(projectRoot, 'package.json');
+  if (existsSync(packageJsonPath)) {
+    try {
+      const content = JSON.parse(readFileSync(packageJsonPath, 'utf-8')) as { name?: string };
+      if (content.name) {
+        return content.name;
+      }
+    } catch {
+      // Ignore parse errors
+    }
+  }
+
+  // Fall back to directory name
+  return basename(projectRoot);
+}
+
+/**
+ * Generate config file content
+ */
+function generateConfigYaml(options: {
+  name: string;
+  type: ProjectType;
+  gitInfo?: { provider?: GitProvider; owner?: string; repo?: string } | null;
+}): string {
+  let yaml = `# CoreAI Configuration
+# See https://coreai.dev/docs/config for full schema
+
+version: "1.0"
+
+project:
+  name: "${options.name}"
+  type: ${options.type}
+
+team:
+  agents:
+    - backend-engineer
+    - frontend-engineer
+    - devops-engineer
+    - engineering-manager
+`;
+
+  if (options.gitInfo?.provider) {
+    yaml += `
+integrations:
+  git:
+    provider: ${options.gitInfo.provider}
+    config:
+      owner: "${options.gitInfo.owner}"
+      repo: "${options.gitInfo.repo}"
+`;
+  }
+
+  yaml += `
+# quality_gates:
+#   lint:
+#     command: npm run lint
+#     required: true
+#   test:
+#     command: npm test
+#     required: true
+#   build:
+#     command: npm run build
+#     required: true
+
+# tech_stack:
+#   primary_language: typescript
+#   frameworks:
+#     - node.js
+#     - express
+`;
+
+  return yaml;
+}
+
+/**
+ * Create directory structure for CoreAI
+ */
+function createDirectories(projectRoot: string): string[] {
+  const dirs = [
+    join(projectRoot, 'coreai', 'agents'),
+    join(projectRoot, 'coreai', 'commands'),
+    join(projectRoot, '.coreai', 'cache'),
+  ];
+
+  const created: string[] = [];
+
+  for (const dir of dirs) {
+    if (!existsSync(dir)) {
+      mkdirSync(dir, { recursive: true });
+      created.push(dir);
+    }
+  }
+
+  return created;
+}
+
+/**
+ * Initialize a new CoreAI project
+ */
+export function init(options: InitCommandOptions = {}): InitCommandResult {
+  const projectRoot = options.projectRoot ?? process.cwd();
+
+  // Check if config already exists
+  if (configExists(projectRoot) && !options.force) {
+    return {
+      success: false,
+      error: 'CoreAI configuration already exists. Use --force to overwrite.',
+    };
+  }
+
+  // Detect git info
+  const gitInfo = detectGitInfo();
+
+  // Determine project name
+  const name = options.name ?? detectProjectName(projectRoot);
+
+  // Determine project type
+  const type = options.type ?? 'software';
+
+  // Generate config
+  const configContent = generateConfigYaml({ name, type, gitInfo });
+
+  // Write config file
+  const configPath = join(projectRoot, 'coreai.config.yaml');
+  try {
+    writeFileSync(configPath, configContent, 'utf-8');
+  } catch (error) {
+    return {
+      success: false,
+      error: `Failed to write config file: ${error instanceof Error ? error.message : String(error)}`,
+    };
+  }
+
+  // Create directories unless skipped
+  let createdDirs: string[] = [];
+  if (!options.skipDirs) {
+    try {
+      createdDirs = createDirectories(projectRoot);
+    } catch (error) {
+      return {
+        success: false,
+        configPath,
+        error: `Failed to create directories: ${error instanceof Error ? error.message : String(error)}`,
+      };
+    }
+  }
+
+  return {
+    success: true,
+    configPath,
+    createdDirs,
+    gitInfo: gitInfo ?? undefined,
+  };
+}
+
+/**
+ * Format init result for display
+ */
+export function formatInitResult(result: InitCommandResult): string {
+  if (!result.success) {
+    return `Error: ${result.error}`;
+  }
+
+  const lines: string[] = [];
+
+  lines.push('CoreAI project initialized successfully!\n');
+
+  if (result.configPath) {
+    lines.push(`Created: ${result.configPath}`);
+  }
+
+  if (result.createdDirs && result.createdDirs.length > 0) {
+    lines.push('\nCreated directories:');
+    for (const dir of result.createdDirs) {
+      lines.push(`  - ${dir}`);
+    }
+  }
+
+  if (result.gitInfo?.provider) {
+    lines.push(
+      `\nDetected ${result.gitInfo.provider} repository: ${result.gitInfo.owner}/${result.gitInfo.repo}`
+    );
+  }
+
+  lines.push('\nNext steps:');
+  lines.push('  1. Edit coreai.config.yaml to configure your project');
+  lines.push('  2. Run `coreai build` to compile agents');
+  lines.push('  3. Run `coreai validate` to check your setup');
+
+  return lines.join('\n');
+}

package/src/cli/commands/skills.test.ts

@@ -0,0 +1,272 @@
+/**
+ * Skills Command Tests
+ */
+
+import { promises as fs } from 'fs';
+import { join } from 'path';
+import { tmpdir } from 'os';
+import {
+  skillsGenerate,
+  formatSkillsGenerateResult,
+  skillsList,
+  formatSkillsListResult,
+} from './skills.js';
+
+describe('Skills Command', () => {
+  let testDir: string;
+
+  beforeEach(async () => {
+    testDir = join(
+      tmpdir(),
+      `skills-cmd-test-${Date.now()}-${Math.random().toString(36).slice(2)}`
+    );
+    await fs.mkdir(testDir, { recursive: true });
+  });
+
+  afterEach(async () => {
+    try {
+      await fs.rm(testDir, { recursive: true, force: true });
+    } catch {
+      // Ignore cleanup errors
+    }
+  });
+
+  describe('skillsGenerate', () => {
+    it('should generate skills with defaults', () => {
+      const result = skillsGenerate({
+        projectRoot: testDir,
+      });
+
+      expect(result.success).toBe(true);
+      expect(result.result).toBeDefined();
+      expect(result.result?.generated.length).toBeGreaterThan(0);
+    });
+
+    it('should generate skills without config', () => {
+      const result = skillsGenerate({
+        projectRoot: testDir,
+      });
+
+      expect(result.success).toBe(true);
+      expect(result.warnings).toContain(
+        'No configuration file found. Generating skills with defaults.'
+      );
+    });
+
+    it('should generate only core skills', () => {
+      const result = skillsGenerate({
+        projectRoot: testDir,
+        includeCoreSkills: true,
+        includeOptionalSkills: false,
+      });
+
+      expect(result.success).toBe(true);
+      const generated = result.result?.generated ?? [];
+      expect(generated.every((g) => g.category === 'core')).toBe(true);
+    });
+
+    it('should generate specific skills', () => {
+      const result = skillsGenerate({
+        projectRoot: testDir,
+        skills: ['check-inbox', 'delegate'],
+      });
+
+      expect(result.success).toBe(true);
+      expect(result.result?.generated).toHaveLength(2);
+    });
+
+    it('should fail with invalid config', async () => {
+      // Create invalid config
+      await fs.writeFile(join(testDir, 'coreai.config.yaml'), 'invalid: yaml: syntax:::');
+
+      const result = skillsGenerate({
+        projectRoot: testDir,
+      });
+
+      expect(result.success).toBe(false);
+      expect(result.error).toContain('Configuration error');
+    });
+
+    it('should use custom output directory', async () => {
+      const customOutputDir = join(testDir, 'custom', 'skills');
+
+      const result = skillsGenerate({
+        projectRoot: testDir,
+        outputDir: customOutputDir,
+        skills: ['check-inbox'],
+      });
+
+      expect(result.success).toBe(true);
+
+      // Verify file created in custom directory
+      const stat = await fs.stat(join(customOutputDir, 'check-inbox.md'));
+      expect(stat.isFile()).toBe(true);
+    });
+
+    it('should pass custom variables', () => {
+      const result = skillsGenerate({
+        projectRoot: testDir,
+        skills: ['check-inbox'],
+        variables: {
+          CUSTOM_VAR: 'custom-value',
+        },
+      });
+
+      expect(result.success).toBe(true);
+      expect(result.result?.variables.CUSTOM_VAR).toBe('custom-value');
+    });
+  });
+
+  describe('formatSkillsGenerateResult', () => {
+    it('should format success result', () => {
+      const result = skillsGenerate({
+        projectRoot: testDir,
+        skills: ['check-inbox'],
+      });
+
+      const output = formatSkillsGenerateResult(result);
+      expect(output).toContain('Created');
+      expect(output).toContain('check-inbox');
+    });
+
+    it('should format error result', () => {
+      const result = {
+        success: false,
+        error: 'Something went wrong',
+      };
+
+      const output = formatSkillsGenerateResult(result);
+      expect(output).toContain('failed');
+      expect(output).toContain('Something went wrong');
+    });
+
+    it('should include warnings', () => {
+      const result = skillsGenerate({
+        projectRoot: testDir,
+        skills: ['check-inbox'],
+      });
+
+      const output = formatSkillsGenerateResult(result);
+      // Should show warning about missing config
+      expect(output.includes('warning') || output.includes('No configuration')).toBe(false);
+      // This should have the created message
+      expect(output).toContain('Created');
+    });
+  });
+
+  describe('skillsList', () => {
+    it('should list all built-in skills', () => {
+      const result = skillsList();
+
+      expect(result.success).toBe(true);
+      expect(result.skills).toBeDefined();
+      expect(result.skills?.length).toBeGreaterThan(0);
+    });
+
+    it('should list only core skills', () => {
+      const result = skillsList({
+        includeCoreSkills: true,
+        includeOptionalSkills: false,
+      });
+
+      expect(result.success).toBe(true);
+      expect(result.skills?.every((s) => s.category === 'core')).toBe(true);
+    });
+
+    it('should list only optional skills', () => {
+      const result = skillsList({
+        includeCoreSkills: false,
+        includeOptionalSkills: true,
+      });
+
+      expect(result.success).toBe(true);
+      expect(result.skills?.every((s) => s.category === 'optional')).toBe(true);
+    });
+
+    it('should include skill metadata', () => {
+      const result = skillsList();
+
+      expect(result.success).toBe(true);
+      const skill = result.skills?.[0];
+      expect(skill?.name).toBeDefined();
+      expect(skill?.description).toBeDefined();
+      expect(skill?.category).toBeDefined();
+    });
+
+    it('should load custom templates when directory provided', async () => {
+      const customDir = join(testDir, 'templates');
+      await fs.mkdir(customDir, { recursive: true });
+      await fs.writeFile(
+        join(customDir, 'custom-skill.md'),
+        '---\ndescription: My custom skill\n---\nContent'
+      );
+
+      const result = skillsList({
+        customTemplatesDir: customDir,
+      });
+
+      expect(result.success).toBe(true);
+      const customSkill = result.skills?.find((s) => s.name === 'custom-skill');
+      expect(customSkill).toBeDefined();
+      expect(customSkill?.description).toBe('My custom skill');
+    });
+  });
+
+  describe('formatSkillsListResult', () => {
+    it('should format skills list', () => {
+      const result = skillsList();
+      const output = formatSkillsListResult(result);
+
+      expect(output).toContain('Available skills');
+      expect(output).toContain('Core skills');
+    });
+
+    it('should format error result', () => {
+      const result = {
+        success: false,
+        error: 'Failed to list skills',
+      };
+
+      const output = formatSkillsListResult(result);
+      expect(output).toContain('Error');
+      expect(output).toContain('Failed to list skills');
+    });
+
+    it('should show no skills message', () => {
+      const result = {
+        success: true,
+        skills: [],
+      };
+
+      const output = formatSkillsListResult(result);
+      expect(output).toContain('No skills available');
+    });
+
+    it('should group skills by category', () => {
+      const result = skillsList();
+      const output = formatSkillsListResult(result);
+
+      // Should have at least core skills section
+      expect(output).toContain('Core skills');
+    });
+
+    it('should show argument hints', () => {
+      const result = skillsList();
+      const output = formatSkillsListResult(result);
+
+      // Many skills have argument hints
+      expect(output).toContain('Argument:');
+    });
+
+    it('should show dependencies for optional skills', () => {
+      const result = skillsList({
+        includeCoreSkills: false,
+        includeOptionalSkills: true,
+      });
+
+      const output = formatSkillsListResult(result);
+      // Optional skills have dependencies
+      expect(output).toContain('requires:');
+    });
+  });
+});