@deimoscloud/coreai 0.1.8 → 0.1.10

package/src/cli/commands/init.ts

@@ -1,296 +0,0 @@
-/**
- * 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

@@ -1,272 +0,0 @@
-/**
- * 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:');
-    });
-  });
-});