@aicgen/aicgen 1.0.0-beta.1

package/scripts/add-categories.ts

@@ -0,0 +1,87 @@
+#!/usr/bin/env node
+/**
+ * Add category metadata to guideline-mappings.yml based on directory structure
+ */
+
+import { readFile, writeFile } from 'fs/promises';
+import { join } from 'path';
+import YAML from 'yaml';
+
+interface GuidelineMapping {
+  path: string;
+  category?: string;
+  languages?: string[];
+  levels?: string[];
+  architectures?: string[];
+  tags?: string[];
+}
+
+const categoryMap: Record<string, string> = {
+  'language': 'Language',
+  'architecture': 'Architecture',
+  'testing': 'Testing',
+  'security': 'Security',
+  'performance': 'Performance',
+  'api': 'API Design',
+  'database': 'Database',
+  'devops': 'DevOps',
+  'error-handling': 'Error Handling',
+  'patterns': 'Design Patterns',
+  'practices': 'Best Practices',
+  'style': 'Code Style'
+};
+
+function getCategoryFromPath(path: string): string {
+  const firstDir = path.split('/')[0];
+  return categoryMap[firstDir] || 'General';
+}
+
+async function addCategories() {
+  console.log('📝 Adding categories to guideline-mappings.yml...\n');
+
+  const mappingsPath = join(process.cwd(), 'data', 'guideline-mappings.yml');
+
+  const content = await readFile(mappingsPath, 'utf-8');
+  const mappings = YAML.parse(content) as Record<string, GuidelineMapping>;
+
+  let updated = 0;
+
+  for (const [id, mapping] of Object.entries(mappings)) {
+    if (!mapping.category) {
+      mapping.category = getCategoryFromPath(mapping.path);
+      updated++;
+    }
+  }
+
+  const output = YAML.stringify(mappings, {
+    lineWidth: 0,
+    defaultStringType: 'PLAIN'
+  });
+
+  const header = `# Guideline Mappings
+# Defines which guidelines apply to which profiles
+#
+# Format:
+# guideline-id:
+#   path: relative/path/to/guideline.md
+#   category: Guideline category for organization
+#   languages: [list of applicable languages] (optional, if omitted applies to all)
+#   levels: [list of applicable levels] (optional, if omitted applies to all)
+#   architectures: [list of applicable architectures] (optional, if omitted applies to all)
+#   tags: [list of tags for organization]
+
+`;
+
+  await writeFile(mappingsPath, header + output, 'utf-8');
+
+  console.log(`✅ Updated ${updated} mappings with categories`);
+  console.log(`📂 Categories found:`);
+
+  const categories = new Set(Object.values(mappings).map(m => m.category));
+  categories.forEach(cat => console.log(`   - ${cat}`));
+}
+
+addCategories().catch(err => {
+  console.error('❌ Failed:', err);
+  process.exit(1);
+});

package/scripts/build-binary.ts

@@ -0,0 +1,46 @@
+#!/usr/bin/env bun
+import { readFileSync } from 'fs';
+
+const packageJson = JSON.parse(readFileSync('package.json', 'utf-8'));
+const version = packageJson.version;
+
+const platform = process.argv[2] || 'current';
+
+import { mkdirSync } from 'fs';
+
+// Ensure dist exists
+try { mkdirSync('dist'); } catch (e) { }
+
+console.log(`Building binary for ${platform} with version ${version}...`);
+
+const buildConfigs: Record<string, string[]> = {
+  current: ['build', 'src/index.ts', '--compile', '--outfile', 'dist/aicgen'],
+  windows: ['build', 'src/index.ts', '--compile', '--outfile', 'dist/aicgen.exe', '--target=bun-windows-x64'],
+  linux: ['build', 'src/index.ts', '--compile', '--outfile', 'dist/aicgen-linux', '--target=bun-linux-x64'],
+  macos: ['build', 'src/index.ts', '--compile', '--outfile', 'dist/aicgen-macos', '--target=bun-darwin-arm64']
+};
+
+const args = buildConfigs[platform];
+
+if (!args) {
+  console.error(`Unknown platform: ${platform}`);
+  console.error(`Available platforms: ${Object.keys(buildConfigs).join(', ')}`);
+  process.exit(1);
+}
+
+// Add the version define
+args.push('--define', `process.env.APP_VERSION="${version}"`);
+
+const proc = Bun.spawn(['bun', ...args], {
+  stdout: 'inherit',
+  stderr: 'inherit',
+});
+
+const exitCode = await proc.exited;
+
+if (exitCode === 0) {
+  console.log(`✓ Binary built successfully (v${version})`);
+} else {
+  console.error('Build failed');
+  process.exit(exitCode);
+}

package/scripts/embed-data.ts

@@ -0,0 +1,105 @@
+#!/usr/bin/env bun
+/**
+ * Embed all guideline data into a TypeScript file for bundling into binary.
+ * Run: bun run scripts/embed-data.ts
+ */
+
+import { readFile, readdir, writeFile } from 'fs/promises';
+import { join } from 'path';
+import YAML from 'yaml';
+
+interface GuidelineMapping {
+  path: string;
+  languages?: string[];
+  levels?: string[];
+  architectures?: string[];
+  datasources?: string[];
+  tags?: string[];
+}
+
+interface EmbeddedData {
+  mappings: Record<string, GuidelineMapping>;
+  guidelines: Record<string, string>;
+}
+
+async function readGuidelinesRecursively(dir: string, basePath: string = ''): Promise<Record<string, string>> {
+  const guidelines: Record<string, string> = {};
+  const entries = await readdir(dir, { withFileTypes: true });
+
+  for (const entry of entries) {
+    const fullPath = join(dir, entry.name);
+    const relativePath = basePath ? `${basePath}/${entry.name}` : entry.name;
+
+    if (entry.isDirectory()) {
+      const subGuidelines = await readGuidelinesRecursively(fullPath, relativePath);
+      Object.assign(guidelines, subGuidelines);
+    } else if (entry.name.endsWith('.md')) {
+      const content = await readFile(fullPath, 'utf-8');
+      guidelines[relativePath] = content;
+    }
+  }
+
+  return guidelines;
+}
+
+async function embedData() {
+  console.log('📦 Embedding guideline data into TypeScript...\n');
+
+  const dataDir = join(process.cwd(), 'data');
+  const mappingsPath = join(dataDir, 'guideline-mappings.yml');
+
+  // Read mappings
+  const mappingsContent = await readFile(mappingsPath, 'utf-8');
+  const mappings = YAML.parse(mappingsContent) as Record<string, GuidelineMapping>;
+
+  console.log(`  Loaded ${Object.keys(mappings).length} guideline mappings`);
+
+  // Read all guidelines from data directory
+  const guidelines = await readGuidelinesRecursively(dataDir);
+
+  // Remove the mappings file and top-level index from guidelines
+  delete guidelines['guideline-mappings.yml'];
+  delete guidelines['index.md'];
+
+  console.log(`  Loaded ${Object.keys(guidelines).length} markdown files`);
+
+  const data: EmbeddedData = { mappings, guidelines };
+
+  // Generate TypeScript file
+  const output = `// AUTO-GENERATED - DO NOT EDIT
+// Generated by scripts/embed-data.ts
+// Contains all guideline mappings and content embedded for binary distribution
+
+export interface GuidelineMapping {
+  path: string;
+  category?: string;
+  languages?: string[];
+  levels?: string[];
+  architectures?: string[];
+  datasources?: string[];
+  tags?: string[];
+}
+
+export interface EmbeddedData {
+  mappings: Record<string, GuidelineMapping>;
+  guidelines: Record<string, string>;
+}
+
+export const EMBEDDED_DATA: EmbeddedData = ${JSON.stringify(data, null, 2)};
+
+export const GUIDELINE_COUNT = ${Object.keys(guidelines).length};
+export const MAPPING_COUNT = ${Object.keys(mappings).length};
+`;
+
+  const outputPath = join(process.cwd(), 'src', 'embedded-data.ts');
+  await writeFile(outputPath, output, 'utf-8');
+
+  const sizeKB = (output.length / 1024).toFixed(1);
+  console.log(`\n✅ Generated src/embedded-data.ts (${sizeKB} KB)`);
+  console.log(`   ${Object.keys(mappings).length} mappings, ${Object.keys(guidelines).length} guidelines embedded`);
+}
+
+embedData().catch(err => {
+  console.error('❌ Failed to embed data:', err);
+  process.exit(1);
+});

package/scripts/generate-version.ts

@@ -0,0 +1,150 @@
+#!/usr/bin/env bun
+
+/**
+ * Generate version.json with dynamic stats calculated from guideline-mappings.yml
+ */
+
+import { readFileSync, writeFileSync } from 'fs';
+import { parse as parseYAML } from 'yaml';
+import { join } from 'path';
+
+interface GuidelineMapping {
+  path: string;
+  category?: string;
+  languages?: string[];
+  levels?: string[];
+  architectures?: string[];
+  datasources?: string[];
+  tags?: string[];
+}
+
+interface GuidelineMappings {
+  [key: string]: GuidelineMapping;
+}
+
+interface VersionData {
+  version: string;
+  lastUpdated: string;
+  totalGuidelines: number;
+  categories: Record<string, number>;
+  languages: Record<string, number>;
+  architectures: Record<string, number>;
+  levels: Record<string, number>;
+  datasources: Record<string, number>;
+}
+
+const DATA_DIR = join(__dirname, '../data');
+const MAPPINGS_FILE = join(DATA_DIR, 'guideline-mappings.yml');
+const VERSION_FILE = join(DATA_DIR, 'version.json');
+
+function calculateStats(mappings: GuidelineMappings): Omit<VersionData, 'version' | 'lastUpdated'> {
+  const categories: Record<string, number> = {};
+  const languages: Record<string, number> = {};
+  const architectures: Record<string, number> = {};
+  const levels: Record<string, number> = {
+    basic: 0,
+    standard: 0,
+    expert: 0,
+    full: 0
+  };
+  const datasources: Record<string, number> = {};
+
+  const guidelineIds = Object.keys(mappings);
+
+  // Count by category
+  for (const id of guidelineIds) {
+    const mapping = mappings[id];
+
+    if (mapping.category) {
+      categories[mapping.category] = (categories[mapping.category] || 0) + 1;
+    }
+  }
+
+  // Count by language (only language-specific guidelines)
+  for (const id of guidelineIds) {
+    const mapping = mappings[id];
+
+    if (mapping.languages && mapping.languages.length > 0) {
+      for (const lang of mapping.languages) {
+        languages[lang] = (languages[lang] || 0) + 1;
+      }
+    }
+  }
+
+  // Count by architecture (only architecture-specific guidelines)
+  for (const id of guidelineIds) {
+    const mapping = mappings[id];
+
+    if (mapping.architectures && mapping.architectures.length > 0) {
+      for (const arch of mapping.architectures) {
+        architectures[arch] = (architectures[arch] || 0) + 1;
+      }
+    }
+  }
+
+  // Count by level
+  for (const id of guidelineIds) {
+    const mapping = mappings[id];
+    const mappingLevels = mapping.levels || ['basic', 'standard', 'expert', 'full'];
+
+    for (const level of mappingLevels) {
+      if (level in levels) {
+        levels[level]++;
+      }
+    }
+  }
+
+  // Count by datasource (only datasource-specific guidelines)
+  for (const id of guidelineIds) {
+    const mapping = mappings[id];
+
+    if (mapping.datasources && mapping.datasources.length > 0) {
+      for (const ds of mapping.datasources) {
+        datasources[ds] = (datasources[ds] || 0) + 1;
+      }
+    }
+  }
+
+  return {
+    totalGuidelines: guidelineIds.length,
+    categories,
+    languages,
+    architectures,
+    levels,
+    datasources
+  };
+}
+
+function main() {
+  console.log('📊 Generating version.json with dynamic stats...\n');
+
+  // Read guideline mappings
+  const mappingsContent = readFileSync(MAPPINGS_FILE, 'utf-8');
+  const mappings = parseYAML(mappingsContent) as GuidelineMappings;
+
+  // Calculate stats
+  const stats = calculateStats(mappings);
+
+  // Get today's date
+  const today = new Date().toISOString().split('T')[0];
+
+  // Create version data
+  const versionData: VersionData = {
+    version: '1.0.0',
+    lastUpdated: today,
+    ...stats
+  };
+
+  // Write to file
+  writeFileSync(VERSION_FILE, JSON.stringify(versionData, null, 2) + '\n');
+
+  console.log(`✅ Generated ${VERSION_FILE}`);
+  console.log(`   Total guidelines: ${stats.totalGuidelines}`);
+  console.log(`   Categories: ${Object.keys(stats.categories).length}`);
+  console.log(`   Languages: ${Object.keys(stats.languages).length}`);
+  console.log(`   Architectures: ${Object.keys(stats.architectures).length}`);
+  console.log(`   Levels: basic(${stats.levels.basic}), standard(${stats.levels.standard}), expert(${stats.levels.expert}), full(${stats.levels.full})`);
+  console.log(`   Datasources: ${Object.keys(stats.datasources).length}`);
+}
+
+main();

package/scripts/test-decompress.ts

@@ -0,0 +1,27 @@
+import decompress from 'decompress';
+import { writeFile, mkdir } from 'fs/promises';
+import { join } from 'path';
+import { homedir } from 'os';
+import { execSync } from 'child_process';
+
+const url = 'https://api.github.com/repos/lpsandaruwan/aicgen-docs/tarball/0.1.0';
+
+console.log('Downloading tarball...');
+const response = await fetch(url);
+const tarballBuffer = Buffer.from(await response.arrayBuffer());
+
+const testDir = join(homedir(), '.aicgen-test3');
+await mkdir(testDir, { recursive: true });
+
+const tarballPath = join(testDir, 'test.tar.gz');
+await writeFile(tarballPath, tarballBuffer);
+
+console.log('Extracting with decompress...');
+await decompress(tarballPath, testDir);
+
+console.log('Checking files...');
+const result = execSync(`cd "${testDir}" && find . -type f | wc -l`).toString().trim();
+console.log(`Total files extracted: ${result}`);
+
+const result2 = execSync(`cd "${testDir}" && ls`).toString().trim();
+console.log('Extracted contents:', result2);

package/scripts/test-extract.ts

@@ -0,0 +1,31 @@
+import { extract } from 'tar';
+import { mkdir, writeFile, readdir, cp } from 'fs/promises';
+import { join } from 'path';
+import { homedir } from 'os';
+
+const url = 'https://api.github.com/repos/lpsandaruwan/aicgen-docs/tarball/0.1.0';
+
+console.log('Downloading tarball...');
+const response = await fetch(url);
+const tarballBuffer = Buffer.from(await response.arrayBuffer());
+
+const testDir = join(homedir(), '.aicgen-test');
+await mkdir(testDir, { recursive: true });
+
+const tarballPath = join(testDir, 'test.tar.gz');
+await writeFile(tarballPath, tarballBuffer);
+
+console.log('Extracting...');
+await extract({ file: tarballPath, cwd: testDir });
+
+console.log('Listing extracted contents:');
+const entries = await readdir(testDir);
+console.log(entries);
+
+const rootDir = entries.find(e => e.startsWith('lpsandaruwan-aicgen-docs-'));
+if (rootDir) {
+  const extractedPath = join(testDir, rootDir);
+  const extracted = await readdir(extractedPath);
+  console.log('\nFiles in extracted directory:');
+  console.log(extracted);
+}