@aicgen/aicgen 1.0.0-beta.1 → 1.0.0-beta.2

package/src/services/config-generator.ts

@@ -1,150 +0,0 @@
-import { join } from 'path';
-import { exists, readJSON } from '../utils/file.js';
-import { GuidelineLoader } from './guideline-loader.js';
-import { AssistantFileWriter } from './assistant-file-writer.js';
-import { DetectedProject, Language } from '../models/project.js';
-import { ProfileSelection } from '../models/profile.js';
-
-export interface GenerationOptions {
-  projectPath: string;
-  selection: ProfileSelection;
-  customGuidelineIds?: string[];
-  dryRun?: boolean;
-}
-
-export interface GenerationResult {
-  success: boolean;
-  filesGenerated: string[];
-  errors: string[];
-}
-
-export class ConfigGenerator {
-  private guidelineLoader: GuidelineLoader;
-  private fileWriter: AssistantFileWriter;
-
-  static async create(): Promise<ConfigGenerator> {
-    const guidelineLoader = await GuidelineLoader.create();
-    const fileWriter = await AssistantFileWriter.create();
-    return new ConfigGenerator(guidelineLoader, fileWriter);
-  }
-
-  private constructor(guidelineLoader: GuidelineLoader, fileWriter: AssistantFileWriter) {
-    this.guidelineLoader = guidelineLoader;
-    this.fileWriter = fileWriter;
-  }
-
-  async detectProject(projectPath: string): Promise<DetectedProject> {
-    const name = await this.getProjectName(projectPath);
-    const language = await this.detectLanguage(projectPath);
-    const hasExistingConfig = await this.hasExistingConfig(projectPath);
-
-    return { name, language, hasExistingConfig };
-  }
-
-  async generate(options: GenerationOptions): Promise<GenerationResult> {
-    const errors: string[] = [];
-    const filesGenerated: string[] = [];
-
-    try {
-      const guidelineIds = options.customGuidelineIds || this.guidelineLoader.getGuidelinesForProfile(
-        options.selection.language,
-        options.selection.level,
-        options.selection.architecture,
-        options.selection.datasource
-      );
-
-      if (guidelineIds.length === 0) {
-        throw new Error(`No guidelines found for profile: ${options.selection.language}-${options.selection.level}-${options.selection.architecture}`);
-      }
-
-      const files = await this.fileWriter.generateFiles(
-        options.selection.assistant,
-        guidelineIds,
-        options.selection,
-        options.projectPath
-      );
-
-      if (options.dryRun) {
-        return {
-          success: true,
-          filesGenerated: files.map(f => f.path),
-          errors: []
-        };
-      }
-
-      await this.fileWriter.writeFiles(files);
-      files.forEach(f => filesGenerated.push(f.path));
-
-      return {
-        success: true,
-        filesGenerated,
-        errors: []
-      };
-    } catch (error) {
-      errors.push((error as Error).message);
-      return {
-        success: false,
-        filesGenerated,
-        errors
-      };
-    }
-  }
-
-  getStats() {
-    return this.guidelineLoader.getStats();
-  }
-
-  private async getProjectName(projectPath: string): Promise<string> {
-    const pkgPath = join(projectPath, 'package.json');
-    if (await exists(pkgPath)) {
-      try {
-        const pkg = await readJSON<{ name?: string }>(pkgPath);
-        if (pkg.name) return pkg.name;
-      } catch {
-        // Ignore
-      }
-    }
-
-    const parts = projectPath.split(/[/\\]/);
-    return parts[parts.length - 1] || 'project';
-  }
-
-  private async detectLanguage(projectPath: string): Promise<Language> {
-    if (await exists(join(projectPath, 'tsconfig.json'))) {
-      return 'typescript';
-    }
-    if (await exists(join(projectPath, 'package.json'))) {
-      return 'javascript';
-    }
-    if (await exists(join(projectPath, 'requirements.txt')) ||
-        await exists(join(projectPath, 'pyproject.toml')) ||
-        await exists(join(projectPath, 'Pipfile'))) {
-      return 'python';
-    }
-    if (await exists(join(projectPath, 'go.mod'))) {
-      return 'go';
-    }
-    if (await exists(join(projectPath, 'Cargo.toml'))) {
-      return 'rust';
-    }
-    if (await exists(join(projectPath, 'pom.xml')) ||
-        await exists(join(projectPath, 'build.gradle'))) {
-      return 'java';
-    }
-    if (await exists(join(projectPath, 'Gemfile'))) {
-      return 'ruby';
-    }
-    return 'unknown';
-  }
-
-  private async hasExistingConfig(projectPath: string): Promise<boolean> {
-    return (
-      await exists(join(projectPath, 'claude.md')) ||
-      await exists(join(projectPath, '.claude')) ||
-      await exists(join(projectPath, '.github', 'copilot-instructions.md')) ||
-      await exists(join(projectPath, '.gemini')) ||
-      await exists(join(projectPath, '.agent')) ||
-      await exists(join(projectPath, '.codex'))
-    );
-  }
-}

package/src/services/config-manager.ts

@@ -1,70 +0,0 @@
-import { readFile, writeFile, mkdir, access } from 'fs/promises';
-import { join } from 'path';
-import { homedir } from 'os';
-import YAML from 'yaml';
-import { CONFIG } from '../config.js';
-
-export interface UserConfig {
-  initialized?: boolean;
-  lastUpdate?: string;
-  dataVersion?: string;
-  github?: {
-    owner?: string;
-    repo?: string;
-  };
-}
-
-export class ConfigManager {
-  private configPath: string;
-  private config: UserConfig = {};
-
-  constructor() {
-    this.configPath = join(homedir(), CONFIG.CACHE_DIR_NAME, 'config.yml');
-  }
-
-  async load(): Promise<UserConfig> {
-    try {
-      await access(this.configPath);
-      const content = await readFile(this.configPath, 'utf-8');
-      this.config = YAML.parse(content) || {};
-    } catch {
-      // Config doesn't exist yet, use defaults
-      this.config = {
-        initialized: false
-      };
-    }
-    return this.config;
-  }
-
-  async save(): Promise<void> {
-    const dir = join(homedir(), CONFIG.CACHE_DIR_NAME);
-    await mkdir(dir, { recursive: true });
-    await writeFile(this.configPath, YAML.stringify(this.config), 'utf-8');
-  }
-
-  async markInitialized(version: string): Promise<void> {
-    this.config.initialized = true;
-    this.config.dataVersion = version;
-    this.config.lastUpdate = new Date().toISOString();
-    await this.save();
-  }
-
-  async updateDataVersion(version: string): Promise<void> {
-    this.config.dataVersion = version;
-    this.config.lastUpdate = new Date().toISOString();
-    await this.save();
-  }
-
-  isInitialized(): boolean {
-    return this.config.initialized === true;
-  }
-
-  getDataVersion(): string | undefined {
-    return this.config.dataVersion;
-  }
-
-  async setGitHubRepo(owner: string, repo: string): Promise<void> {
-    this.config.github = { owner, repo };
-    await this.save();
-  }
-}

package/src/services/data-source.ts

@@ -1,248 +0,0 @@
-import { readFile, readdir, access } from 'fs/promises';
-import { join } from 'path';
-import YAML from 'yaml';
-import { EMBEDDED_DATA, GuidelineMapping } from '../embedded-data.js';
-
-export interface GuidelineData {
-  mappings: Record<string, GuidelineMapping>;
-  guidelines: Record<string, string>;
-  version?: string;
-}
-
-export interface DataSource {
-  load(): Promise<GuidelineData>;
-  exists(): Promise<boolean>;
-  getVersion(): Promise<string>;
-}
-
-export class EmbeddedDataSource implements DataSource {
-  async load(): Promise<GuidelineData> {
-    return {
-      mappings: EMBEDDED_DATA.mappings,
-      guidelines: EMBEDDED_DATA.guidelines,
-      version: 'embedded'
-    };
-  }
-
-  async exists(): Promise<boolean> {
-    return true;
-  }
-
-  async getVersion(): Promise<string> {
-    return 'embedded';
-  }
-}
-
-export class FileSystemDataSource implements DataSource {
-  constructor(private basePath: string) {}
-
-  async load(): Promise<GuidelineData> {
-    const mappingsPath = join(this.basePath, 'guideline-mappings.yml');
-    const mappingsContent = await readFile(mappingsPath, 'utf-8');
-    const mappings = YAML.parse(mappingsContent) as Record<string, GuidelineMapping>;
-
-    const guidelines: Record<string, string> = {};
-    const guidelinesDir = join(this.basePath, 'guidelines');
-
-    try {
-      await this.loadGuidelinesRecursive(guidelinesDir, '', guidelines);
-    } catch {
-      // Guidelines directory might not exist yet
-    }
-
-    const version = await this.readVersion();
-
-    return { mappings, guidelines, version };
-  }
-
-  async exists(): Promise<boolean> {
-    try {
-      await access(join(this.basePath, 'guideline-mappings.yml'));
-      return true;
-    } catch {
-      return false;
-    }
-  }
-
-  async getVersion(): Promise<string> {
-    return await this.readVersion();
-  }
-
-  private async readVersion(): Promise<string> {
-    try {
-      const versionPath = join(this.basePath, 'version.json');
-      const versionContent = await readFile(versionPath, 'utf-8');
-      const versionData = JSON.parse(versionContent);
-      return versionData.version || 'unknown';
-    } catch {
-      return 'unknown';
-    }
-  }
-
-  private async loadGuidelinesRecursive(
-    dir: string,
-    relativePath: string,
-    guidelines: Record<string, string>
-  ): Promise<void> {
-    try {
-      const entries = await readdir(dir, { withFileTypes: true });
-
-      for (const entry of entries) {
-        const fullPath = join(dir, entry.name);
-        const relPath = relativePath ? `${relativePath}/${entry.name}` : entry.name;
-
-        if (entry.isDirectory()) {
-          await this.loadGuidelinesRecursive(fullPath, relPath, guidelines);
-        } else if (entry.name.endsWith('.md')) {
-          const content = await readFile(fullPath, 'utf-8');
-          guidelines[relPath] = content;
-        }
-      }
-    } catch {
-      // Directory might not exist
-    }
-  }
-}
-
-export class CustomMappingsDataSource implements DataSource {
-  constructor(private basePath: string) {}
-
-  async load(): Promise<GuidelineData> {
-    const mappingsPath = join(this.basePath, 'custom-mappings.yml');
-
-    let mappings: Record<string, GuidelineMapping> = {};
-    try {
-      const mappingsContent = await readFile(mappingsPath, 'utf-8');
-      mappings = YAML.parse(mappingsContent) as Record<string, GuidelineMapping>;
-    } catch {
-      // Custom mappings don't exist yet
-    }
-
-    const guidelines: Record<string, string> = {};
-    const guidelinesDir = join(this.basePath, 'guidelines');
-
-    try {
-      await this.loadGuidelinesRecursive(guidelinesDir, '', guidelines);
-    } catch {
-      // Guidelines directory might not exist yet
-    }
-
-    return { mappings, guidelines, version: 'custom' };
-  }
-
-  async exists(): Promise<boolean> {
-    try {
-      await access(join(this.basePath, 'custom-mappings.yml'));
-      return true;
-    } catch {
-      // Check if guidelines directory exists
-      try {
-        await access(join(this.basePath, 'guidelines'));
-        return true;
-      } catch {
-        return false;
-      }
-    }
-  }
-
-  async getVersion(): Promise<string> {
-    return 'custom';
-  }
-
-  private async loadGuidelinesRecursive(
-    dir: string,
-    relativePath: string,
-    guidelines: Record<string, string>
-  ): Promise<void> {
-    try {
-      const entries = await readdir(dir, { withFileTypes: true });
-
-      for (const entry of entries) {
-        const fullPath = join(dir, entry.name);
-        const relPath = relativePath ? `${relativePath}/${entry.name}` : entry.name;
-
-        if (entry.isDirectory()) {
-          await this.loadGuidelinesRecursive(fullPath, relPath, guidelines);
-        } else if (entry.name.endsWith('.md')) {
-          const content = await readFile(fullPath, 'utf-8');
-          guidelines[relPath] = content;
-        }
-      }
-    } catch {
-      // Directory might not exist
-    }
-  }
-}
-
-export class HybridDataSource implements DataSource {
-  constructor(private sources: DataSource[]) {}
-
-  async load(): Promise<GuidelineData> {
-    const results = await Promise.all(
-      this.sources.map(async (source) => {
-        if (await source.exists()) {
-          try {
-            return await source.load();
-          } catch (error) {
-            console.warn(`Failed to load from data source: ${error}`);
-            return null;
-          }
-        }
-        return null;
-      })
-    );
-
-    const validResults = results.filter((r): r is GuidelineData => r !== null);
-
-    if (validResults.length === 0) {
-      throw new Error('No data sources available');
-    }
-
-    return this.merge(validResults);
-  }
-
-  async exists(): Promise<boolean> {
-    const exists = await Promise.all(this.sources.map((s) => s.exists()));
-    return exists.some((e) => e);
-  }
-
-  async getVersion(): Promise<string> {
-    for (const source of this.sources) {
-      if (await source.exists()) {
-        const version = await source.getVersion();
-        if (version !== 'custom' && version !== 'unknown') {
-          return version;
-        }
-      }
-    }
-    return 'embedded';
-  }
-
-  private merge(dataArray: GuidelineData[]): GuidelineData {
-    // Merge with priority: first source has highest priority
-    const merged: GuidelineData = {
-      mappings: {},
-      guidelines: {},
-      version: dataArray[0]?.version || 'unknown'
-    };
-
-    // Merge in reverse order so earlier sources override later ones
-    for (let i = dataArray.length - 1; i >= 0; i--) {
-      const data = dataArray[i];
-      Object.assign(merged.mappings, data.mappings);
-      Object.assign(merged.guidelines, data.guidelines);
-
-      // Use the first non-custom, non-unknown version
-      if (
-        data.version &&
-        data.version !== 'custom' &&
-        data.version !== 'unknown' &&
-        (merged.version === 'unknown' || merged.version === 'custom')
-      ) {
-        merged.version = data.version;
-      }
-    }
-
-    return merged;
-  }
-}

package/src/services/first-run-init.ts

@@ -1,148 +0,0 @@
-import { mkdir, writeFile, readdir, cp, rm } from 'fs/promises';
-import { join } from 'path';
-import { homedir } from 'os';
-import chalk from 'chalk';
-import ora from 'ora';
-import { CONFIG, GITHUB_RELEASES_URL } from '../config.js';
-import { ConfigManager } from './config-manager.js';
-
-const DOWNLOAD_TIMEOUT_MS = 30000; // 30 seconds
-const MAX_TARBALL_SIZE_BYTES = 10 * 1024 * 1024; // 10MB max
-
-export async function ensureDataInitialized(): Promise<void> {
-  const configManager = new ConfigManager();
-  await configManager.load();
-
-  if (configManager.isInitialized()) {
-    return; // Already initialized
-  }
-
-  console.log(chalk.cyan('\n🚀 First-time setup...\n'));
-
-  const spinner = ora('Downloading latest guidelines from GitHub...').start();
-
-  try {
-    await downloadFromGitHub();
-    spinner.succeed('Downloaded latest guidelines from GitHub');
-    await configManager.markInitialized('latest');
-    console.log(chalk.green('✓ Using latest guidelines from GitHub\n'));
-  } catch {
-    spinner.info('Could not reach GitHub, using bundled guidelines');
-    await configManager.markInitialized('embedded');
-    console.log(chalk.green('✓ Using bundled guidelines\n'));
-  }
-
-  console.log(chalk.gray('  Tip: Run `aicgen update` anytime to sync with latest guidelines\n'));
-}
-
-async function downloadFromGitHub(): Promise<void> {
-  const controller = new AbortController();
-  const timeout = setTimeout(() => controller.abort(), DOWNLOAD_TIMEOUT_MS);
-
-  try {
-    const response = await fetch(GITHUB_RELEASES_URL, {
-      headers: {
-        'Accept': 'application/vnd.github+json',
-        'User-Agent': CONFIG.USER_AGENT
-      },
-      signal: controller.signal
-    });
-
-    if (!response.ok) {
-      throw new Error(`GitHub API returned ${response.status}`);
-    }
-
-    const data = await response.json() as { tag_name: string; tarball_url: string };
-    const version = data.tag_name.replace(/^v/, '');
-
-    const cacheDir = join(homedir(), CONFIG.CACHE_DIR_NAME, CONFIG.CACHE_DIR);
-    await mkdir(cacheDir, { recursive: true });
-
-    // Download tarball with timeout and size limit
-    const tarballController = new AbortController();
-    const tarballTimeout = setTimeout(() => tarballController.abort(), DOWNLOAD_TIMEOUT_MS);
-
-    try {
-      const tarballResponse = await fetch(data.tarball_url, {
-        signal: tarballController.signal
-      });
-
-      if (!tarballResponse.ok) {
-        throw new Error(`Failed to download tarball: ${tarballResponse.status}`);
-      }
-
-      // Check content-length if available
-      const contentLength = tarballResponse.headers.get('content-length');
-      if (contentLength && parseInt(contentLength, 10) > MAX_TARBALL_SIZE_BYTES) {
-        throw new Error(`Tarball too large: ${contentLength} bytes (max ${MAX_TARBALL_SIZE_BYTES})`);
-      }
-
-      const tarballBuffer = Buffer.from(await tarballResponse.arrayBuffer());
-
-      // Verify size after download
-      if (tarballBuffer.length > MAX_TARBALL_SIZE_BYTES) {
-        throw new Error(`Downloaded tarball too large: ${tarballBuffer.length} bytes`);
-      }
-
-      const tempDir = join(cacheDir, '.temp-extract');
-      await mkdir(tempDir, { recursive: true });
-
-      try {
-        // Write tarball to temp file
-        const tarballPath = join(tempDir, 'archive.tar.gz');
-        await writeFile(tarballPath, tarballBuffer);
-
-        // Extract tarball using decompress (Windows-compatible)
-        const decompress = (await import('decompress')).default;
-        await decompress(tarballPath, tempDir);
-
-        // Find extracted directory - derive from CONFIG instead of hardcoding
-        const entries = await readdir(tempDir);
-        const expectedPrefix = `${CONFIG.GITHUB_REPO_OWNER}-${CONFIG.GITHUB_REPO_NAME}-`;
-        const rootDir = entries.find(entry => entry.startsWith(expectedPrefix));
-
-        if (!rootDir) {
-          throw new Error(`Could not find extracted repository directory (expected ${expectedPrefix}*)`);
-        }
-
-        const extractedPath = join(tempDir, rootDir);
-
-        // Copy contents to cache directory with proper structure
-        const guidelinesTarget = join(cacheDir, 'guidelines');
-        await mkdir(guidelinesTarget, { recursive: true });
-
-        // Copy extracted contents with correct structure
-        const extractedEntries = await readdir(extractedPath, { withFileTypes: true });
-        for (const entry of extractedEntries) {
-          const sourcePath = join(extractedPath, entry.name);
-          const targetPath = join(guidelinesTarget, entry.name);
-
-          if (entry.name === 'guideline-mappings.yml') {
-            await cp(sourcePath, join(cacheDir, entry.name));
-          } else if (entry.isDirectory() || entry.name.endsWith('.md')) {
-            await cp(sourcePath, targetPath, { recursive: true });
-          }
-        }
-
-        // Write version file
-        await writeFile(
-          join(cacheDir, 'version.json'),
-          JSON.stringify({ version, updatedAt: new Date().toISOString(), source: 'github' }),
-          'utf-8'
-        );
-      } finally {
-        await rm(tempDir, { recursive: true, force: true });
-      }
-    } finally {
-      clearTimeout(tarballTimeout);
-    }
-  } finally {
-    clearTimeout(timeout);
-  }
-}
-
-export async function shouldRunFirstTimeSetup(): Promise<boolean> {
-  const configManager = new ConfigManager();
-  await configManager.load();
-  return !configManager.isInitialized();
-}