architect-ai 1.1.0

package/dist/lib.d.ts

@@ -0,0 +1,186 @@
+/**
+ * Type definitions for architect-ai CLI
+ */
+interface ProjectConfig {
+    techStack?: string;
+    rules?: string[];
+    bypassKeyword?: string;
+    commitFormat?: string;
+    maxConcurrency?: number;
+    cacheEnabled?: boolean;
+}
+interface AuditIssue {
+    line: number;
+    severity: 'CRITICAL' | 'WARNING' | 'INFO';
+    message: string;
+    suggestion: string;
+}
+interface AuditResult {
+    status: 'PASS' | 'FAIL';
+    issues?: AuditIssue[];
+    message?: string;
+    suggestion?: string;
+}
+interface FileAuditResult {
+    filePath: string;
+    result: AuditResult;
+    duration: number;
+}
+interface CLIOptions {
+    files?: string[];
+    commit?: boolean;
+    bypass?: boolean;
+    verbose?: boolean;
+    maxConcurrency?: number;
+    targetBranch?: string;
+}
+declare const DEFAULT_CONFIG: Required<ProjectConfig>;
+
+/**
+ * Configuration loader with caching and validation
+ */
+
+/**
+ * Load and validate project configuration
+ */
+declare const loadProjectConfig: (cwd?: string) => Promise<ProjectConfig>;
+/**
+ * Clear config cache (useful for testing)
+ */
+declare const clearConfigCache: () => void;
+/**
+ * Validate configuration schema
+ */
+declare const validateConfig: (config: unknown) => config is ProjectConfig;
+
+/**
+ * Git utilities with async support and better error handling
+ */
+interface GitDiffOptions {
+    targetBranch?: string;
+    extensions?: RegExp;
+}
+/**
+ * Get last commit message asynchronously
+ */
+declare const getLastCommitMessage: () => Promise<string>;
+/**
+ * Get changed files against target branch with parallel execution
+ */
+declare const getChangedFiles: (options?: GitDiffOptions) => Promise<string[]>;
+/**
+ * Check if current directory is a git repository
+ */
+declare const isGitRepository: () => Promise<boolean>;
+/**
+ * Get current branch name
+ */
+declare const getCurrentBranch: () => Promise<string>;
+
+/**
+ * Parsing utilities for AI responses
+ */
+
+/**
+ * Clean JSON from markdown code blocks
+ */
+declare const cleanJSON: (text: string) => string;
+/**
+ * Parse AI response to AuditResult with error handling
+ */
+declare const parseAuditResponse: (responseText: string) => AuditResult;
+/**
+ * Format file size for display
+ */
+declare const formatBytes: (bytes: number) => string;
+/**
+ * Format duration for display
+ */
+declare const formatDuration$1: (ms: number) => string;
+
+/**
+ * Console output utilities with colors
+ */
+declare const log: {
+    info: (msg: string) => void;
+    success: (msg: string) => void;
+    warning: (msg: string) => void;
+    error: (msg: string) => void;
+    critical: (msg: string) => void;
+    audit: (msg: string) => void;
+    skip: (msg: string) => void;
+    file: (msg: string) => void;
+    issue: (severity: string, line: number, message: string) => void;
+    progress: (current: number, total: number, label: string) => void;
+    progressEnd: () => void;
+    divider: () => void;
+    header: (title: string) => void;
+};
+/**
+ * Format duration for display
+ */
+declare const formatDuration: (ms: number) => string;
+
+/**
+ * Core AI service with singleton pattern and request pooling
+ */
+
+/**
+ * Audit commit message
+ */
+declare const auditCommit: (message: string, config: ProjectConfig) => Promise<AuditResult>;
+/**
+ * Audit single file
+ */
+declare const auditFile: (filePath: string, content: string, systemPrompt: string) => Promise<AuditResult>;
+/**
+ * Audit multiple files with concurrency control
+ */
+declare const auditFilesWithConcurrency: (files: Array<{
+    path: string;
+    content: string;
+}>, config: ProjectConfig, maxConcurrency?: number) => Promise<FileAuditResult[]>;
+/**
+ * Clear model cache (useful for testing)
+ */
+declare const clearModelCache: () => void;
+
+/**
+ * File service with streaming support and memory optimization
+ */
+
+interface FileContent {
+    path: string;
+    content: string;
+    size: number;
+}
+interface FileReadResult {
+    success: FileContent[];
+    skipped: Array<{
+        path: string;
+        reason: string;
+    }>;
+}
+/**
+ * Read multiple files efficiently with size limits
+ */
+declare const readFilesForAudit: (filePaths: string[]) => Promise<FileReadResult>;
+/**
+ * Get file extension without dot
+ */
+declare const getFileExtension: (filePath: string) => string;
+/**
+ * Check if file is a code file
+ */
+declare const isCodeFile: (filePath: string) => boolean;
+
+/**
+ * Prompt templates for AI-powered code auditing
+ */
+
+declare const DEFAULT_COMMIT_PROMPT = "\n### ROLE\nYou are a Strict Release Manager. You enforce \"Conventional Commits\" standards.\n### RULES\n1. Format MUST be: `<type>(<scope>): <subject>`\n   - Types: feat, fix, docs, style, refactor, perf, test, build, ci, chore, revert.\n   - Example: \"feat(auth): add google login support\"\n2. Subject must be lowercase and imperative (e.g., \"add\" not \"added\").\n3. Message must be descriptive enough to understand the change context.\n";
+declare const BASE_AUDIT_PROMPT = "\n### ROLE & OBJECTIVE\nYou are an Elite Software Architect. Your goal is to enforce \"Clean Code\", \"SOLID Principles\", and \"Maintainability\".\n### GLOBAL STANDARDS\n1. **Clean Code:** Variable/Function names must be semantic. No magic numbers.\n2. **Split Code:** Suggest splitting complex functions/components.\n3. **Performance:** Identify obvious bottlenecks.\n4. **Error Handling:** Ensure proper boundary checks.\n";
+declare const buildSystemPrompt: (config: ProjectConfig) => string;
+declare const buildCommitPrompt: (customFormat?: string) => string;
+
+export { type AuditIssue, type AuditResult, BASE_AUDIT_PROMPT, type CLIOptions, DEFAULT_COMMIT_PROMPT, DEFAULT_CONFIG, type FileAuditResult, type FileContent, type FileReadResult, type ProjectConfig, auditCommit, auditFile, auditFilesWithConcurrency, buildCommitPrompt, buildSystemPrompt, cleanJSON, clearConfigCache, clearModelCache, formatBytes, formatDuration, formatDuration$1 as formatDurationParser, getChangedFiles, getCurrentBranch, getFileExtension, getLastCommitMessage, isCodeFile, isGitRepository, loadProjectConfig, log, parseAuditResponse, readFilesForAudit, validateConfig };

package/dist/lib.js

@@ -0,0 +1,443 @@
+import { readFile, stat } from 'fs/promises';
+import { existsSync } from 'fs';
+import { resolve } from 'path';
+import { exec } from 'child_process';
+import { promisify } from 'util';
+import { GoogleGenerativeAI } from '@google/generative-ai';
+
+// Architect AI - CLI
+
+
+// src/types/index.ts
+var DEFAULT_CONFIG = {
+  techStack: "",
+  rules: [],
+  bypassKeyword: "skip:",
+  commitFormat: "",
+  maxConcurrency: 5,
+  cacheEnabled: true
+};
+var cachedConfig = null;
+var loadProjectConfig = async (cwd = process.cwd()) => {
+  if (cachedConfig) {
+    return cachedConfig;
+  }
+  const configPath = resolve(cwd, ".architectrc.json");
+  if (!existsSync(configPath)) {
+    cachedConfig = { ...DEFAULT_CONFIG };
+    return cachedConfig;
+  }
+  try {
+    const content = await readFile(configPath, "utf-8");
+    const userConfig = JSON.parse(content);
+    cachedConfig = {
+      ...DEFAULT_CONFIG,
+      ...userConfig
+    };
+    console.log("\u2699\uFE0F  Loaded project-specific rules from .architectrc.json");
+    return cachedConfig;
+  } catch (error) {
+    console.warn("\u26A0\uFE0F  Found .architectrc.json but failed to parse it.");
+    cachedConfig = { ...DEFAULT_CONFIG };
+    return cachedConfig;
+  }
+};
+var clearConfigCache = () => {
+  cachedConfig = null;
+};
+var validateConfig = (config) => {
+  if (typeof config !== "object" || config === null) {
+    return false;
+  }
+  const c = config;
+  if (c.techStack !== void 0 && typeof c.techStack !== "string") {
+    return false;
+  }
+  if (c.rules !== void 0 && !Array.isArray(c.rules)) {
+    return false;
+  }
+  if (c.bypassKeyword !== void 0 && typeof c.bypassKeyword !== "string") {
+    return false;
+  }
+  if (c.commitFormat !== void 0 && typeof c.commitFormat !== "string") {
+    return false;
+  }
+  if (c.maxConcurrency !== void 0 && typeof c.maxConcurrency !== "number") {
+    return false;
+  }
+  return true;
+};
+var execAsync = promisify(exec);
+var SUPPORTED_EXTENSIONS = /\.(ts|tsx|js|jsx|mjs|cjs|py|cs|go|java|rs|kt|swift)$/;
+var getLastCommitMessage = async () => {
+  try {
+    const { stdout } = await execAsync("git log -1 --pretty=%B");
+    return stdout.trim();
+  } catch {
+    return "";
+  }
+};
+var getChangedFiles = async (options = {}) => {
+  const { targetBranch = "origin/main", extensions = SUPPORTED_EXTENSIONS } = options;
+  try {
+    const command = `git diff --name-only --diff-filter=ACMR ${targetBranch}...HEAD`;
+    const { stdout } = await execAsync(command);
+    return parseAndFilterFiles(stdout, extensions);
+  } catch {
+    try {
+      const command = `git diff --name-only --diff-filter=ACMR ${targetBranch}`;
+      const { stdout } = await execAsync(command);
+      return parseAndFilterFiles(stdout, extensions);
+    } catch {
+      console.warn("\u26A0\uFE0F  Git diff failed. No files to audit.");
+      return [];
+    }
+  }
+};
+var isGitRepository = async () => {
+  try {
+    await execAsync("git rev-parse --is-inside-work-tree");
+    return true;
+  } catch {
+    return false;
+  }
+};
+var getCurrentBranch = async () => {
+  try {
+    const { stdout } = await execAsync("git branch --show-current");
+    return stdout.trim();
+  } catch {
+    return "unknown";
+  }
+};
+var parseAndFilterFiles = (output, extensions) => {
+  return output.split("\n").map((file) => file.trim()).filter((file) => file.length > 0).filter((file) => extensions.test(file));
+};
+
+// src/utils/parser.ts
+var cleanJSON = (text) => {
+  return text.replace(/```json\s*/gi, "").replace(/```\s*/g, "").trim();
+};
+var parseAuditResponse = (responseText) => {
+  const cleaned = cleanJSON(responseText);
+  try {
+    const parsed = JSON.parse(cleaned);
+    if (!parsed.status || !["PASS", "FAIL"].includes(parsed.status)) {
+      return {
+        status: "FAIL",
+        message: "Invalid AI response format",
+        issues: []
+      };
+    }
+    return parsed;
+  } catch {
+    const jsonMatch = cleaned.match(/\{[\s\S]*\}/);
+    if (jsonMatch) {
+      try {
+        return JSON.parse(jsonMatch[0]);
+      } catch {
+      }
+    }
+    return {
+      status: "FAIL",
+      message: "Failed to parse AI response",
+      issues: []
+    };
+  }
+};
+var formatBytes = (bytes) => {
+  if (bytes === 0) return "0 B";
+  const k = 1024;
+  const sizes = ["B", "KB", "MB", "GB"];
+  const i = Math.floor(Math.log(bytes) / Math.log(k));
+  return `${parseFloat((bytes / Math.pow(k, i)).toFixed(2))} ${sizes[i]}`;
+};
+var formatDuration = (ms) => {
+  if (ms < 1e3) return `${ms}ms`;
+  if (ms < 6e4) return `${(ms / 1e3).toFixed(1)}s`;
+  return `${(ms / 6e4).toFixed(1)}m`;
+};
+
+// src/utils/logger.ts
+var colors = {
+  reset: "\x1B[0m",
+  bold: "\x1B[1m",
+  dim: "\x1B[2m",
+  red: "\x1B[31m",
+  green: "\x1B[32m",
+  yellow: "\x1B[33m",
+  blue: "\x1B[34m",
+  magenta: "\x1B[35m",
+  cyan: "\x1B[36m"};
+var log = {
+  info: (msg) => console.log(`${colors.blue}\u2139${colors.reset} ${msg}`),
+  success: (msg) => console.log(`${colors.green}\u2705${colors.reset} ${msg}`),
+  warning: (msg) => console.warn(`${colors.yellow}\u26A0\uFE0F${colors.reset}  ${msg}`),
+  error: (msg) => console.error(`${colors.red}\u274C${colors.reset} ${msg}`),
+  critical: (msg) => console.error(`${colors.red}${colors.bold}\u{1F6A8}${colors.reset} ${msg}`),
+  audit: (msg) => console.log(`${colors.cyan}\u{1F50D}${colors.reset} ${msg}`),
+  skip: (msg) => console.log(`${colors.magenta}\u23E9${colors.reset} ${msg}`),
+  file: (msg) => console.log(`${colors.dim}   ${msg}${colors.reset}`),
+  // Issue formatting
+  issue: (severity, line, message) => {
+    const color = severity === "CRITICAL" ? colors.red : severity === "WARNING" ? colors.yellow : colors.blue;
+    console.log(`   ${color}[${severity}] Line ${line}: ${message}${colors.reset}`);
+  },
+  // Progress bar
+  progress: (current, total, label) => {
+    const percent = Math.round(current / total * 100);
+    const barLength = 20;
+    const filled = Math.round(current / total * barLength);
+    const bar = "\u2588".repeat(filled) + "\u2591".repeat(barLength - filled);
+    process.stdout.write(`\r${colors.cyan}${bar}${colors.reset} ${percent}% | ${label}`);
+  },
+  progressEnd: () => {
+    console.log();
+  },
+  // Divider
+  divider: () => console.log(`${colors.dim}${"\u2500".repeat(50)}${colors.reset}`),
+  // Header
+  header: (title) => {
+    console.log();
+    console.log(`${colors.bold}${colors.cyan}\u{1F3D7}\uFE0F  ${title}${colors.reset}`);
+    console.log(`${colors.dim}${"\u2500".repeat(50)}${colors.reset}`);
+  }
+};
+var formatDuration2 = (ms) => {
+  if (ms < 1e3) return `${Math.round(ms)}ms`;
+  if (ms < 6e4) return `${(ms / 1e3).toFixed(1)}s`;
+  return `${(ms / 6e4).toFixed(1)}m`;
+};
+
+// src/config/prompts.ts
+var DEFAULT_COMMIT_PROMPT = `
+### ROLE
+You are a Strict Release Manager. You enforce "Conventional Commits" standards.
+### RULES
+1. Format MUST be: \`<type>(<scope>): <subject>\`
+   - Types: feat, fix, docs, style, refactor, perf, test, build, ci, chore, revert.
+   - Example: "feat(auth): add google login support"
+2. Subject must be lowercase and imperative (e.g., "add" not "added").
+3. Message must be descriptive enough to understand the change context.
+`;
+var BASE_AUDIT_PROMPT = `
+### ROLE & OBJECTIVE
+You are an Elite Software Architect. Your goal is to enforce "Clean Code", "SOLID Principles", and "Maintainability".
+### GLOBAL STANDARDS
+1. **Clean Code:** Variable/Function names must be semantic. No magic numbers.
+2. **Split Code:** Suggest splitting complex functions/components.
+3. **Performance:** Identify obvious bottlenecks.
+4. **Error Handling:** Ensure proper boundary checks.
+`;
+var buildSystemPrompt = (config) => {
+  const parts = [BASE_AUDIT_PROMPT];
+  if (config.techStack) {
+    parts.push(`
+### TECH STACK CONTEXT
+The code is written in: ${config.techStack}
+`);
+  }
+  if (config.rules && config.rules.length > 0) {
+    parts.push(`
+### PROJECT SPECIFIC RULES (HIGHEST PRIORITY)
+`);
+    config.rules.forEach((rule, index) => {
+      parts.push(`${index + 1}. ${rule}
+`);
+    });
+  }
+  parts.push(`
+### OUTPUT FORMAT (JSON ONLY)
+{ "status": "PASS" | "FAIL", "issues": [{ "line": number, "severity": "CRITICAL" | "WARNING", "message": "string", "suggestion": "string" }] }`);
+  return parts.join("");
+};
+var buildCommitPrompt = (customFormat) => {
+  const parts = [];
+  if (customFormat) {
+    parts.push(`
+### ROLE
+You are a Strict Release Manager. 
+### RULES (CUSTOM COMPANY POLICY)
+You must enforce the following strict commit message format:
+"${customFormat}"
+
+Any commit message NOT following this pattern must be REJECTED.
+    `);
+  } else {
+    parts.push(DEFAULT_COMMIT_PROMPT);
+  }
+  parts.push(`
+### OUTPUT (JSON ONLY)
+{ "status": "PASS" | "FAIL", "message": "Reason for failure", "suggestion": "Corrected example" }`);
+  return parts.join("");
+};
+
+// src/services/ai.ts
+var modelInstance = null;
+var getModel = () => {
+  if (modelInstance) {
+    return modelInstance;
+  }
+  const apiKey = process.env.GEMINI_API_KEY;
+  if (!apiKey) {
+    throw new Error("GEMINI_API_KEY environment variable is required");
+  }
+  const genAI = new GoogleGenerativeAI(apiKey);
+  modelInstance = genAI.getGenerativeModel({
+    model: "gemini-1.5-pro",
+    generationConfig: {
+      temperature: 0.2,
+      maxOutputTokens: 8192
+    }
+  });
+  return modelInstance;
+};
+var auditCommit = async (message, config) => {
+  log.audit(`Auditing Commit Message: "${message}"...`);
+  const systemPrompt = buildCommitPrompt(config.commitFormat);
+  const model = getModel();
+  try {
+    const result = await model.generateContent([
+      systemPrompt,
+      `Commit Message: "${message}"`
+    ]);
+    return parseAuditResponse(result.response.text());
+  } catch (error) {
+    log.warning("AI check failed. Skipping commit check.");
+    return { status: "PASS", message: "AI unavailable - skipped" };
+  }
+};
+var auditFile = async (filePath, content, systemPrompt) => {
+  const model = getModel();
+  try {
+    const result = await model.generateContent([
+      systemPrompt,
+      `Code to review:
+${content}`
+    ]);
+    return parseAuditResponse(result.response.text());
+  } catch (error) {
+    return {
+      status: "FAIL",
+      message: `Error auditing file: ${error instanceof Error ? error.message : "Unknown error"}`,
+      issues: []
+    };
+  }
+};
+var auditFilesWithConcurrency = async (files, config, maxConcurrency = 5) => {
+  const systemPrompt = buildSystemPrompt(config);
+  const results = [];
+  for (let i = 0; i < files.length; i += maxConcurrency) {
+    const batch = files.slice(i, i + maxConcurrency);
+    const batchPromises = batch.map(async (file) => {
+      const startTime = performance.now();
+      log.audit(`Auditing: ${file.path}`);
+      const result = await auditFile(file.path, file.content, systemPrompt);
+      const duration = performance.now() - startTime;
+      return {
+        filePath: file.path,
+        result,
+        duration
+      };
+    });
+    const batchResults = await Promise.all(batchPromises);
+    results.push(...batchResults);
+    log.progress(
+      Math.min(i + maxConcurrency, files.length),
+      files.length,
+      `${results.length}/${files.length} files audited`
+    );
+  }
+  log.progressEnd();
+  return results;
+};
+var clearModelCache = () => {
+  modelInstance = null;
+};
+var MAX_FILE_SIZE = 500 * 1024;
+var readFilesForAudit = async (filePaths) => {
+  const result = {
+    success: [],
+    skipped: []
+  };
+  const readPromises = filePaths.map(async (filePath) => {
+    const absolutePath = resolve(filePath);
+    if (!existsSync(absolutePath)) {
+      return { path: filePath, skipped: true, reason: "File not found" };
+    }
+    try {
+      const stats = await stat(absolutePath);
+      if (stats.size > MAX_FILE_SIZE) {
+        return {
+          path: filePath,
+          skipped: true,
+          reason: `File too large (${formatBytes(stats.size)})`
+        };
+      }
+      const content = await readFile(absolutePath, "utf-8");
+      return {
+        path: filePath,
+        content,
+        size: stats.size,
+        skipped: false
+      };
+    } catch (error) {
+      return {
+        path: filePath,
+        skipped: true,
+        reason: error instanceof Error ? error.message : "Read error"
+      };
+    }
+  });
+  const results = await Promise.all(readPromises);
+  for (const item of results) {
+    if (item.skipped) {
+      result.skipped.push({ path: item.path, reason: item.reason });
+    } else {
+      result.success.push({
+        path: item.path,
+        content: item.content,
+        size: item.size
+      });
+    }
+  }
+  if (result.skipped.length > 0) {
+    log.warning(`Skipped ${result.skipped.length} file(s):`);
+    for (const { path, reason } of result.skipped) {
+      log.file(`${path}: ${reason}`);
+    }
+  }
+  return result;
+};
+var getFileExtension = (filePath) => {
+  const match = filePath.match(/\.([^.]+)$/);
+  return match?.[1] ?? "";
+};
+var isCodeFile = (filePath) => {
+  const codeExtensions = /* @__PURE__ */ new Set([
+    "ts",
+    "tsx",
+    "js",
+    "jsx",
+    "mjs",
+    "cjs",
+    "py",
+    "cs",
+    "go",
+    "java",
+    "rs",
+    "kt",
+    "swift",
+    "cpp",
+    "c",
+    "h",
+    "hpp",
+    "rb",
+    "php"
+  ]);
+  return codeExtensions.has(getFileExtension(filePath));
+};
+
+export { BASE_AUDIT_PROMPT, DEFAULT_COMMIT_PROMPT, DEFAULT_CONFIG, auditCommit, auditFile, auditFilesWithConcurrency, buildCommitPrompt, buildSystemPrompt, cleanJSON, clearConfigCache, clearModelCache, formatBytes, formatDuration2 as formatDuration, formatDuration as formatDurationParser, getChangedFiles, getCurrentBranch, getFileExtension, getLastCommitMessage, isCodeFile, isGitRepository, loadProjectConfig, log, parseAuditResponse, readFilesForAudit, validateConfig };
+//# sourceMappingURL=lib.js.map
+//# sourceMappingURL=lib.js.map