pixelcrew 0.2.2 → 0.2.6

package/src/adapters/kiro.js

@@ -0,0 +1,134 @@
+/**
+ * PIXEL CREW — Kiro Adapter
+ * 
+ * Execution adapter for Kiro coding agent runtime.
+ */
+
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import os from 'node:os';
+import { spawn } from 'node:child_process';
+import { AgentAdapter } from './adapter.interface.js';
+
+export class KiroAdapter extends AgentAdapter {
+  constructor(options = {}) {
+    super('kiro', 'Kiro', {
+      icon: '🗡️',
+      description: 'Kiro autonomous agent and multi-agent runtime',
+      capabilities: {
+        fileAccess: true,
+        terminalAccess: true,
+        subagents: true,
+        backgroundTasks: true,
+        streaming: true,
+        toolCalls: true
+      },
+      ...options
+    });
+  }
+
+  async detectScore(targetDir = process.cwd()) {
+    let score = 0;
+
+    // 1. Environment variables (Active Kiro session/agent environment) (+1000 points)
+    if (
+      process.env.KIRO ||
+      process.env.KIRO_AGENT ||
+      process.env.KIRO_SESSION ||
+      process.env.KIRO_WORKSPACE ||
+      process.env.KIRO_APP_DIR ||
+      process.env.KIRO_CONFIG_DIR ||
+      process.env.KIRO_PATH
+    ) {
+      score += 1000;
+    }
+
+    // 2. Target Workspace files/folders (.kiro, .kirorules, kiro.json, .kiro.json) (+200 points)
+    const indicators = ['.kiro', '.kirorules', 'kiro.json', '.kiro.json'];
+    for (const item of indicators) {
+      try {
+        await fs.access(path.join(targetDir, item));
+        score += 200;
+        break;
+      } catch {}
+    }
+
+    // 3. User Home Directory (~/.kiro, ~/.config/kiro) (+50 points)
+    try {
+      const home = os.homedir();
+      if (home) {
+        try {
+          await fs.access(path.join(home, '.kiro'));
+          score += 50;
+        } catch {}
+        try {
+          await fs.access(path.join(home, '.config', 'kiro'));
+          score += 50;
+        } catch {}
+      }
+    } catch {}
+
+    // 4. macOS Application bundle detection (+30 points)
+    if (process.platform === 'darwin') {
+      const macApps = [
+        '/Applications/Kiro.app',
+        path.join(os.homedir() || '', 'Applications', 'Kiro.app'),
+        '/Applications/Kiro IDE.app'
+      ];
+      for (const appPath of macApps) {
+        try {
+          await fs.access(appPath);
+          score += 30;
+          break;
+        } catch {}
+      }
+    }
+
+    // 5. Binary CLI in PATH (kiro, kiro-cli, kiro-agent, kiro-ai) (+30 points)
+    const binaries = ['kiro', 'kiro-cli', 'kiro-agent', 'kiro-ai'];
+    for (const bin of binaries) {
+      const isFound = await new Promise((resolve) => {
+        try {
+          const cmd = process.platform === 'win32' ? 'where' : 'which';
+          const proc = spawn(cmd, [bin], { stdio: 'ignore' });
+          proc.on('close', (code) => resolve(code === 0));
+          proc.on('error', () => resolve(false));
+        } catch {
+          resolve(false);
+        }
+      });
+      if (isFound) {
+        score += 30;
+        break;
+      }
+    }
+
+    return score;
+  }
+
+  async detect(targetDir = process.cwd()) {
+    const score = await this.detectScore(targetDir);
+    return score > 0;
+  }
+
+  async execute(task, context = {}) {
+    const { emit = () => {}, signal } = context;
+
+    if (signal?.aborted) {
+      throw new Error(`Task ${task.id} cancelled before start`);
+    }
+
+    await emit('tool.invoked', `Kiro agent executing task: ${task.title}`);
+
+    if (context.executeTaskHandler) {
+      return await context.executeTaskHandler(task, emit);
+    }
+
+    await new Promise(r => setTimeout(r, 200));
+    return {
+      success: true,
+      provider: this.id,
+      taskId: task.id
+    };
+  }
+}

package/src/adapters/registry.js

@@ -0,0 +1,150 @@
+/**
+ * PIXEL CREW — Provider Registry & Dynamic Strategy Engine
+ * 
+ * Manages coding agent providers, executes environment scans, and resolves
+ * the optimal adapter based on task requirements and selected runtime strategies.
+ */
+
+import { GenericAdapter } from './generic.js';
+import { ClaudeCodeAdapter } from './claude-code.js';
+import { CodexAdapter } from './codex.js';
+import { CursorAdapter } from './cursor.js';
+import { KiroAdapter } from './kiro.js';
+import { AntigravityAdapter } from './antigravity.js';
+
+export class ProviderRegistry {
+  constructor() {
+    this.adapters = new Map();
+    this.detectedCache = new Map();
+    this.lastScanTime = 0;
+
+    // Register built-in providers
+    this.registerAdapter(new GenericAdapter());
+    this.registerAdapter(new ClaudeCodeAdapter());
+    this.registerAdapter(new CodexAdapter());
+    this.registerAdapter(new CursorAdapter());
+    this.registerAdapter(new KiroAdapter());
+    this.registerAdapter(new AntigravityAdapter());
+  }
+
+  registerAdapter(adapter) {
+    if (!adapter?.id) {
+      throw new Error('Adapter must have a unique id');
+    }
+    this.adapters.set(adapter.id, adapter);
+  }
+
+  getAdapter(id) {
+    return this.adapters.get(id) || null;
+  }
+
+  getAllAdapters() {
+    return Array.from(this.adapters.values());
+  }
+
+  /**
+   * Scans system to detect available providers and determine the active runtime
+   * @param {boolean} forceRefresh
+   * @param {string} targetDir
+   * @returns {Promise<{ activeProvider: string, activeProviderName: string, activeProviderIcon: string, activeProviderDescription: string, available: import('./adapter.interface.js').AgentAdapter[], missing: import('./adapter.interface.js').AgentAdapter[] }>}
+   */
+  async scanEnvironment(forceRefresh = false, targetDir = process.cwd()) {
+    const now = Date.now();
+    if (!forceRefresh && now - this.lastScanTime < 4000 && this.detectedCache.size > 0 && this.lastScanResult) {
+      return this.lastScanResult;
+    }
+
+    const availableWithScores = [];
+    const missing = [];
+
+    for (const adapter of this.adapters.values()) {
+      try {
+        const score = typeof adapter.detectScore === 'function' 
+          ? await adapter.detectScore(targetDir) 
+          : ((await adapter.detect(targetDir)) ? 100 : 0);
+
+        this.detectedCache.set(adapter.id, score > 0);
+        if (score > 0) {
+          availableWithScores.push({ adapter, score });
+        } else {
+          missing.push(adapter);
+        }
+      } catch {
+        this.detectedCache.set(adapter.id, false);
+        missing.push(adapter);
+      }
+    }
+
+    // Sort available adapters by confidence score descending
+    availableWithScores.sort((a, b) => {
+      // Prioritize higher score
+      if (b.score !== a.score) return b.score - a.score;
+      // If score is equal, prioritize Antigravity / Kiro / Claude over generic
+      if (a.adapter.id === 'generic') return 1;
+      if (b.adapter.id === 'generic') return -1;
+      return 0;
+    });
+
+    const available = availableWithScores.map(item => item.adapter);
+    const top = available.find(a => a.id !== 'generic') || available[0] || this.getAdapter('generic');
+
+    this.lastScanTime = now;
+    this.lastScanResult = {
+      activeProvider: top?.id || 'generic',
+      activeProviderName: top?.name || 'Generic CLI Runner',
+      activeProviderIcon: top?.icon || '💻',
+      activeProviderDescription: top?.description || '',
+      available,
+      missing
+    };
+
+    return this.lastScanResult;
+  }
+
+  /**
+   * Selects the best adapter for a given task based on strategy
+   * @param {import('../protocol/task.js').AgentTask} task
+   * @param {string} strategy - 'auto' | 'hybrid' | specific provider id
+   */
+  async getBestAgent(task, strategy = 'auto') {
+    // If specific adapter explicitly requested
+    if (strategy && strategy !== 'auto' && strategy !== 'hybrid') {
+      const explicit = this.getAdapter(strategy);
+      if (explicit) return explicit;
+    }
+
+    // Check if task itself specifies an assigned provider
+    if (task?.assignedProvider) {
+      const assigned = this.getAdapter(task.assignedProvider);
+      if (assigned) return assigned;
+    }
+
+    const { activeProvider, available } = await this.scanEnvironment();
+
+    if (strategy === 'hybrid') {
+      // Hybrid crew strategy:
+      // - Design / Frontend -> Claude Code / Cursor / Antigravity
+      // - Backend / Data -> Codex / Antigravity / Kiro
+      // - QA / Review -> Claude Code / Generic / Antigravity
+      if (task.agent === 'frontend' || task.agent === 'creativeDirector') {
+        const preferred = available.find(a => a.id === 'claude-code' || a.id === 'cursor' || a.id === 'antigravity');
+        if (preferred) return preferred;
+      } else if (task.agent === 'backend' || task.agent === 'database') {
+        const preferred = available.find(a => a.id === 'codex' || a.id === 'antigravity' || a.id === 'kiro');
+        if (preferred) return preferred;
+      }
+    }
+
+    // In 'auto' mode: Use the top-scored active provider
+    if (activeProvider) {
+      const activeAdapter = this.getAdapter(activeProvider);
+      if (activeAdapter) return activeAdapter;
+    }
+
+    if (available.length > 0) {
+      return available[0];
+    }
+
+    return this.getAdapter('generic');
+  }
+}

package/src/backend/analyzer/complexity-analyzer.js

@@ -0,0 +1,104 @@
+/**
+ * PIXEL CREW — Architecture Complexity Analyzer
+ * 
+ * Computes multi-dimensional complexity scores and prevents over-engineering
+ * by ensuring architectural choices match actual application constraints.
+ */
+
+export class ComplexityAnalyzer {
+  /**
+   * Calculate complexity score across 6 architectural dimensions
+   * @param {object} requirements - SystemRequirementsModel
+   * @param {object} ast - Semantic Project AST
+   * @returns {object} Complexity Assessment
+   */
+  static analyze(requirements = {}, ast = {}) {
+    const app = requirements.application || {};
+    const users = requirements.users || {};
+    const data = requirements.data || {};
+    const api = requirements.api || {};
+    const security = requirements.security || {};
+    const performance = requirements.performance || {};
+    const jobs = requirements.backgroundJobs || {};
+
+    const entities = ast.entities || [];
+    const workflows = ast.workflows || [];
+    const operations = ast.operations || [];
+
+    // 1. Domain Complexity (0–25)
+    let domainScore = 5;
+    if (entities.length > 5) domainScore += 5;
+    if (entities.length > 10) domainScore += 5;
+    if (workflows.length > 3) domainScore += 5;
+    if (users.roles && users.organizations) domainScore += 5;
+
+    // 2. Traffic & Concurrency Complexity (0–20)
+    let trafficScore = 3;
+    if (app.expectedScale === 'medium') trafficScore += 5;
+    if (app.expectedScale === 'high') trafficScore += 12;
+    if (performance.realTime) trafficScore += 5;
+
+    // 3. Data & Storage Complexity (0–20)
+    let dataScore = 4;
+    if (data.transactions) dataScore += 5;
+    if (data.search) dataScore += 3;
+    if (data.auditLog) dataScore += 3;
+    if (security.tenantIsolation) dataScore += 5;
+
+    // 4. Integration & Background Processing (0–15)
+    let integrationScore = 2;
+    if (jobs.required) integrationScore += 5;
+    if (jobs.tasks && jobs.tasks.length > 2) integrationScore += 4;
+    if (api.public) integrationScore += 4;
+
+    // 5. Reliability & Availability Requirements (0–10)
+    let reliabilityScore = 2;
+    if (app.availability === '99.9%') reliabilityScore += 3;
+    if (app.availability === '99.99%') reliabilityScore += 6;
+    if (data.transactions) reliabilityScore += 2;
+
+    // 6. Security Complexity (0–10)
+    let securityScore = 2;
+    if (security.tenantIsolation) securityScore += 3;
+    if (security.sensitiveData) securityScore += 3;
+    if (security.auditLogging) securityScore += 2;
+
+    const totalScore = domainScore + trafficScore + dataScore + integrationScore + reliabilityScore + securityScore;
+
+    // Determine Tier
+    let tier = 'low';
+    let recommendedStyle = 'modular-monolith';
+    let allowedInfrastructure = ['postgresql', 'sqlite', 'in-memory-cache'];
+    let disallowedInfrastructure = ['microservices', 'kubernetes', 'kafka', 'service-mesh'];
+
+    if (totalScore >= 60) {
+      tier = 'high';
+      recommendedStyle = 'distributed-modular-services';
+      allowedInfrastructure.push('redis', 'bullmq', 'cdn-edge', 'worker-cluster');
+      if (totalScore > 80) {
+        disallowedInfrastructure = []; // Complex requirements may justify advanced distributed infra
+      }
+    } else if (totalScore >= 35) {
+      tier = 'medium';
+      recommendedStyle = 'modular-monolith-with-workers';
+      allowedInfrastructure.push('redis', 'bullmq');
+    }
+
+    return {
+      totalScore,
+      tier, // 'low' | 'medium' | 'high'
+      recommendedStyle,
+      dimensions: {
+        domain: domainScore,
+        traffic: trafficScore,
+        data: dataScore,
+        integration: integrationScore,
+        reliability: reliabilityScore,
+        security: securityScore
+      },
+      allowedInfrastructure,
+      disallowedInfrastructure,
+      summary: `Complexity score ${totalScore}/100 (${tier} complexity). Recommended architecture: ${recommendedStyle}.`
+    };
+  }
+}

package/src/backend/analyzer/requirement-analyzer.js

@@ -0,0 +1,213 @@
+/**
+ * PIXEL CREW — System Requirement Analyzer
+ * 
+ * Analyzes natural language intent and project AST to extract a structured,
+ * machine-verifiable SystemRequirementsModel without domain hardcoding.
+ */
+
+export class RequirementAnalyzer {
+  /**
+   * Extract comprehensive backend requirements from prompt & AST
+   * @param {string} prompt 
+   * @param {object} ast 
+   * @returns {object} SystemRequirementsModel
+   */
+  static analyze(prompt = '', ast = {}) {
+    const rawPrompt = String(prompt).toLowerCase();
+    const domain = (ast.domain || '').toLowerCase();
+    const entities = ast.entities || [];
+    const workflows = ast.workflows || [];
+    const operations = ast.operations || [];
+
+    // 1. Application Scale & Multi-tenancy Inferences
+    const isMultiTenant = Boolean(
+      rawPrompt.includes('tenant') ||
+      rawPrompt.includes('organization') ||
+      rawPrompt.includes('workspace') ||
+      rawPrompt.includes('b2b') ||
+      rawPrompt.includes('team') ||
+      entities.some(e => ['Organization', 'Workspace', 'Tenant', 'Team', 'Account'].includes(e.name))
+    );
+
+    const isHighScale = Boolean(
+      rawPrompt.includes('high throughput') ||
+      rawPrompt.includes('streaming') ||
+      rawPrompt.includes('million') ||
+      rawPrompt.includes('distributed') ||
+      rawPrompt.includes('large scale') ||
+      rawPrompt.includes('real-time analytics')
+    );
+
+    const scale = isHighScale ? 'high' : (isMultiTenant ? 'medium' : 'low');
+
+    // 2. User & Authentication Inferences
+    const hasAuth = Boolean(
+      rawPrompt.includes('login') ||
+      rawPrompt.includes('auth') ||
+      rawPrompt.includes('user') ||
+      rawPrompt.includes('account') ||
+      rawPrompt.includes('sign in') ||
+      rawPrompt.includes('permission') ||
+      rawPrompt.includes('role') ||
+      isMultiTenant ||
+      (ast.actors && ast.actors.length > 1)
+    );
+
+    const hasRoles = Boolean(
+      rawPrompt.includes('role') ||
+      rawPrompt.includes('admin') ||
+      rawPrompt.includes('rbac') ||
+      rawPrompt.includes('permission') ||
+      (ast.actors && ast.actors.length > 1)
+    );
+
+    // 3. Data Inferences
+    const hasTransactions = Boolean(
+      rawPrompt.includes('payment') ||
+      rawPrompt.includes('checkout') ||
+      rawPrompt.includes('transfer') ||
+      rawPrompt.includes('order') ||
+      rawPrompt.includes('booking') ||
+      rawPrompt.includes('reservation') ||
+      rawPrompt.includes('inventory') ||
+      rawPrompt.includes('financial') ||
+      rawPrompt.includes('ledger') ||
+      rawPrompt.includes('atomic') ||
+      workflows.some(w => /pay|order|book|reserve|transfer|transact/i.test(w.name || ''))
+    );
+
+    const hasSearch = Boolean(
+      rawPrompt.includes('search') ||
+      rawPrompt.includes('filter') ||
+      rawPrompt.includes('catalog') ||
+      rawPrompt.includes('browse') ||
+      operations.some(op => (op.path || '').includes('search'))
+    );
+
+    // 4. API Inferences
+    const isPublicAPI = Boolean(
+      rawPrompt.includes('public api') ||
+      rawPrompt.includes('webhook') ||
+      rawPrompt.includes('developer platform') ||
+      rawPrompt.includes('sdk')
+    );
+
+    const rateLimiting = Boolean(
+      hasAuth ||
+      isPublicAPI ||
+      rawPrompt.includes('rate limit') ||
+      isMultiTenant
+    );
+
+    // 5. Security Inferences
+    const hasSensitiveData = Boolean(
+      rawPrompt.includes('health') ||
+      rawPrompt.includes('patient') ||
+      rawPrompt.includes('emr') ||
+      rawPrompt.includes('payment') ||
+      rawPrompt.includes('credit card') ||
+      rawPrompt.includes('pii') ||
+      rawPrompt.includes('contract') ||
+      rawPrompt.includes('legal') ||
+      rawPrompt.includes('secret') ||
+      rawPrompt.includes('password')
+    );
+
+    const auditLogging = Boolean(
+      isMultiTenant ||
+      hasSensitiveData ||
+      hasTransactions ||
+      rawPrompt.includes('audit') ||
+      rawPrompt.includes('compliance')
+    );
+
+    // 6. Performance & Asynchronous Jobs Inferences
+    const isReadHeavy = !rawPrompt.includes('write intensive') && !rawPrompt.includes('ingest');
+    const isRealTime = Boolean(
+      rawPrompt.includes('realtime') ||
+      rawPrompt.includes('real-time') ||
+      rawPrompt.includes('websocket') ||
+      rawPrompt.includes('live') ||
+      rawPrompt.includes('chat') ||
+      rawPrompt.includes('collaboration')
+    );
+
+    const backgroundJobs = Boolean(
+      rawPrompt.includes('job') ||
+      rawPrompt.includes('queue') ||
+      rawPrompt.includes('worker') ||
+      rawPrompt.includes('email') ||
+      rawPrompt.includes('export') ||
+      rawPrompt.includes('import') ||
+      rawPrompt.includes('report') ||
+      rawPrompt.includes('video') ||
+      rawPrompt.includes('transcription') ||
+      rawPrompt.includes('render') ||
+      rawPrompt.includes('batch') ||
+      rawPrompt.includes('notification')
+    );
+
+    return {
+      application: {
+        name: ast.appName || 'Application',
+        domain: domain || 'general',
+        type: isMultiTenant ? 'multi-tenant SaaS' : (isHighScale ? 'high-throughput system' : 'modular application'),
+        expectedScale: scale,
+        availability: isHighScale ? '99.99%' : (isMultiTenant ? '99.9%' : '99.5%')
+      },
+      users: {
+        authentication: hasAuth,
+        strategy: hasAuth ? (isMultiTenant ? 'session' : 'session') : 'none',
+        roles: hasRoles,
+        organizations: isMultiTenant
+      },
+      data: {
+        relational: true,
+        transactions: hasTransactions,
+        search: hasSearch,
+        softDelete: isMultiTenant || hasSensitiveData,
+        auditLog: auditLogging
+      },
+      api: {
+        style: 'REST',
+        versioning: true,
+        public: isPublicAPI,
+        rateLimiting,
+        errorFormat: 'RFC-7807'
+      },
+      security: {
+        sensitiveData: hasSensitiveData,
+        tenantIsolation: isMultiTenant,
+        auditLogging,
+        strictValidation: true,
+        denyByDefault: true
+      },
+      performance: {
+        readHeavy: isReadHeavy,
+        realTime: isRealTime,
+        caching: hasSearch || isReadHeavy || isMultiTenant,
+        paginationStrategy: (isHighScale || hasSearch) ? 'cursor' : 'offset'
+      },
+      backgroundJobs: {
+        required: backgroundJobs,
+        tasks: this.extractJobTasks(rawPrompt)
+      }
+    };
+  }
+
+  /**
+   * Helper: Extracts discrete background job types
+   */
+  static extractJobTasks(prompt) {
+    const tasks = [];
+    if (prompt.includes('email') || prompt.includes('notification')) tasks.push('send-notifications');
+    if (prompt.includes('export') || prompt.includes('report')) tasks.push('generate-reports');
+    if (prompt.includes('import') || prompt.includes('csv')) tasks.push('batch-import');
+    if (prompt.includes('video') || prompt.includes('image') || prompt.includes('transcription')) tasks.push('media-processing');
+    if (prompt.includes('webhook')) tasks.push('webhook-dispatch');
+    if (tasks.length === 0 && (prompt.includes('worker') || prompt.includes('queue'))) {
+      tasks.push('async-task-worker');
+    }
+    return tasks;
+  }
+}