create-genia-os 2.4.1 → 3.0.0

package/template/.aiox-core/framework-config.yaml

@@ -0,0 +1,158 @@
+# ============================================
+# AIOX Framework Configuration (Level 1)
+# ============================================
+# DO NOT EDIT — This file is part of the AIOX framework.
+# Override values in project-config.yaml or local-config.yaml.
+#
+# Level: L1 (Framework)
+# Mutability: Read-only (shipped with npm package)
+# Git status: Committed (framework source)
+# ADR: ADR-PRO-002 — Configuration Hierarchy
+# ============================================
+
+# --- Metadata (framework portion) ---
+metadata:
+  name: "Synkra AIOX"
+  framework_version: "4.0.0"
+
+markdownExploder: true
+
+# --- Resource Locations (Section 3) ---
+resource_locations:
+  agents_dir: ".aiox-core/development/agents"
+  tasks_dir: ".aiox-core/development/tasks"
+  templates_dir: ".aiox-core/development/templates"
+  checklists_dir: ".aiox-core/development/checklists"
+  tools_dir: ".aiox-core/tools"
+  scripts:
+    core: ".aiox-core/core"
+    development: ".aiox-core/development/scripts"
+    infrastructure: ".aiox-core/infrastructure/scripts"
+    legacy: ".aiox-core/scripts"
+  data_dir: ".aiox-core/data"
+  elicitation_dir: ".aiox-core/elicitation"
+  squads_template_dir: "templates/squad"
+  minds_dir: "outputs/minds"
+
+# --- Performance Defaults (Section 6 - defaults only) ---
+performance_defaults:
+  lazy_loading:
+    enabled: true
+    heavy_sections:
+      - pvMindContext
+      - squads
+      - registry
+  git:
+    show_config_warning: true
+    cache_time_seconds: 300
+
+# --- Utility Scripts Registry (Section 11) ---
+utility_scripts_registry:
+  # Agent Helper utilities (28) — Used directly by agents
+  helpers:
+    - batch-creator
+    - capability-analyzer
+    - change-propagation-predictor
+    - clickup-helpers
+    - code-quality-improver
+    - compatibility-checker
+    - component-metadata
+    - component-preview
+    - conflict-manager
+    - coverage-analyzer
+    - dependency-analyzer
+    - diff-generator
+    - framework-analyzer
+    - git-wrapper
+    - manifest-preview
+    - migration-path-generator
+    - migration-tester
+    - modification-history
+    - modification-risk-assessment
+    - modification-validator
+    - performance-analyzer
+    - redundancy-analyzer
+    - refactoring-suggester
+    - sandbox-tester
+    - template-validator
+    - test-quality-assessment
+    - validate-filenames
+    - version-tracker
+    - visual-impact-generator
+
+  # Task Execution utilities (17) — Called during task execution
+  executors:
+    - approval-workflow
+    - branch-manager
+    - commit-message-generator
+    - component-generator
+    - component-search
+    - conflict-resolver
+    - deprecation-manager
+    - dependency-impact-analyzer
+    - documentation-synchronizer
+    - migration-generator
+    - migration-rollback
+    - modification-synchronizer
+    - performance-optimizer
+    - rollback-handler
+    - safe-removal-handler
+    - test-generator
+    - test-updater
+
+  # Framework utilities (11) — Framework-level components
+  framework:
+    - elicitation-engine
+    - elicitation-session-manager
+    - improvement-engine
+    - improvement-validator
+    - metrics-tracker
+    - pattern-learner
+    - template-engine
+    - test-template-system
+    - transaction-manager
+    - usage-analytics
+    - usage-tracker
+
+# --- IDE Sync System (Section 12) ---
+ide_sync_system:
+  enabled: true
+  source: ".aiox-core/development/agents"
+  targets:
+    claude-code:
+      enabled: true
+      path: ".claude/commands/AIOX/agents"
+      format: "full-markdown-yaml"
+    codex:
+      enabled: true
+      path: ".codex/agents"
+      format: "full-markdown-yaml"
+    gemini:
+      enabled: true
+      path: ".gemini/rules/AIOX/agents"
+      format: "full-markdown-yaml"
+    github-copilot:
+      enabled: true
+      path: ".github/agents"
+      format: "full-markdown-yaml"
+    cursor:
+      enabled: true
+      path: ".cursor/rules/agents"
+      format: "condensed-rules"
+    antigravity:
+      enabled: true
+      path: ".antigravity/rules/agents"
+      format: "cursor-style"
+  redirects: {}
+  validation:
+    strict_mode: true
+    fail_on_drift: true
+    fail_on_orphaned: false
+
+# --- Template Override Defaults (Section 13) ---
+# Override in project-config.yaml to customize story template rendering.
+# null = use template default order; [] = no optional sections.
+template_overrides:
+  story:
+    sections_order: null
+    optional_sections: []

package/template/.aiox-core/hooks/gemini/after-tool.js

@@ -0,0 +1,77 @@
+#!/usr/bin/env node
+/**
+ * AIOX After Tool Hook for Gemini CLI
+ * Story GEMINI-INT.6 - AIOX Hooks System
+ *
+ * Executes after tool completion for audit logging.
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+async function afterTool() {
+  const input = process.argv[2] ? JSON.parse(process.argv[2]) : {};
+  const toolName = input.tool || '';
+  const toolResult = input.result || {};
+
+  // Log execution result
+  logToolResult(toolName, toolResult);
+
+  // Track file modifications
+  if (toolName === 'write_file' || toolName === 'replace' || toolName === 'edit') {
+    trackFileModification(input.args?.path || input.args?.file_path);
+  }
+
+  console.log(JSON.stringify({ status: 'success' }));
+  process.exit(0);
+}
+
+function logToolResult(tool, result) {
+  try {
+    const projectDir = process.env.GEMINI_PROJECT_DIR || process.cwd();
+    const logDir = path.join(projectDir, '.aiox', 'logs');
+
+    if (!fs.existsSync(logDir)) {
+      fs.mkdirSync(logDir, { recursive: true });
+    }
+
+    const logEntry = {
+      timestamp: new Date().toISOString(),
+      tool,
+      success: result.success !== false,
+      provider: 'gemini',
+      sessionId: process.env.GEMINI_SESSION_ID,
+    };
+
+    const logPath = path.join(logDir, 'tool-results.jsonl');
+    fs.appendFileSync(logPath, JSON.stringify(logEntry) + '\n');
+  } catch (error) {
+    // Non-critical
+  }
+}
+
+function trackFileModification(filePath) {
+  if (!filePath) return;
+
+  try {
+    const projectDir = process.env.GEMINI_PROJECT_DIR || process.cwd();
+    const trackPath = path.join(projectDir, '.aiox', 'session-files.json');
+
+    let files = [];
+    if (fs.existsSync(trackPath)) {
+      files = JSON.parse(fs.readFileSync(trackPath, 'utf8'));
+    }
+
+    if (!files.includes(filePath)) {
+      files.push(filePath);
+      fs.writeFileSync(trackPath, JSON.stringify(files, null, 2));
+    }
+  } catch (error) {
+    // Non-critical
+  }
+}
+
+afterTool().catch((error) => {
+  console.log(JSON.stringify({ status: 'error', error: error.message }));
+  process.exit(0);
+});

package/template/.aiox-core/hooks/gemini/before-agent.js

@@ -0,0 +1,79 @@
+#!/usr/bin/env node
+/**
+ * AIOX Before Agent Hook for Gemini CLI
+ * Story GEMINI-INT.6 - AIOX Hooks System
+ *
+ * Executes before agent processing to inject gotchas and patterns.
+ * Output must be valid JSON to stdout.
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+async function beforeAgent() {
+  const projectDir = process.env.GEMINI_PROJECT_DIR || process.cwd();
+
+  const result = {
+    status: 'success',
+    contextInjection: {
+      gotchas: [],
+      patterns: [],
+      conventions: {},
+    },
+  };
+
+  // Load gotchas
+  try {
+    const gotchasPath = path.join(projectDir, '.aiox', 'gotchas.json');
+    if (fs.existsSync(gotchasPath)) {
+      const gotchas = JSON.parse(fs.readFileSync(gotchasPath, 'utf8'));
+      result.contextInjection.gotchas = gotchas.slice(0, 5); // Top 5 recent
+    }
+  } catch (error) {
+    // Non-critical
+  }
+
+  // Load patterns from codebase map
+  try {
+    const codebaseMapPath = path.join(projectDir, '.aiox', 'codebase-map.json');
+    if (fs.existsSync(codebaseMapPath)) {
+      const map = JSON.parse(fs.readFileSync(codebaseMapPath, 'utf8'));
+      if (map.patterns) {
+        result.contextInjection.patterns = map.patterns.slice(0, 5);
+      }
+      if (map.conventions) {
+        result.contextInjection.conventions = map.conventions;
+      }
+    }
+  } catch (error) {
+    // Non-critical
+  }
+
+  // Load CLAUDE.md conventions (works for both CLIs)
+  try {
+    const claudeMdPath = path.join(projectDir, '.claude', 'CLAUDE.md');
+    if (fs.existsSync(claudeMdPath)) {
+      const content = fs.readFileSync(claudeMdPath, 'utf8');
+      // Extract key sections
+      const importConventions = content.match(/## (?:Code Standards|Conventions)([\s\S]*?)(?=##|$)/i);
+      if (importConventions) {
+        result.contextInjection.projectConventions = importConventions[1].trim().slice(0, 500);
+      }
+    }
+  } catch (error) {
+    // Non-critical
+  }
+
+  return result;
+}
+
+// Execute and output JSON
+beforeAgent()
+  .then((result) => {
+    console.log(JSON.stringify(result));
+    process.exit(0);
+  })
+  .catch((error) => {
+    console.log(JSON.stringify({ status: 'error', error: error.message }));
+    process.exit(0);
+  });

package/template/.aiox-core/hooks/gemini/before-tool.js

@@ -0,0 +1,114 @@
+#!/usr/bin/env node
+/**
+ * AIOX Before Tool Hook for Gemini CLI
+ * Story GEMINI-INT.6 - AIOX Hooks System
+ *
+ * Executes before tool execution for security validation.
+ * Can block dangerous operations.
+ * Exit code 2 = block, Exit code 0 = allow.
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+// Patterns to block
+const BLOCKED_PATTERNS = [
+  /api[_-]?key\s*[:=]\s*['"][^'"]+['"]/i,
+  /password\s*[:=]\s*['"][^'"]+['"]/i,
+  /secret\s*[:=]\s*['"][^'"]+['"]/i,
+  /AKIA[0-9A-Z]{16}/i, // AWS key
+  /ghp_[a-zA-Z0-9]{36}/, // GitHub token
+  /sk-[a-zA-Z0-9]{48}/, // OpenAI key
+];
+
+// Dangerous commands to warn about
+const DANGEROUS_COMMANDS = [
+  'rm -rf /',
+  'rm -rf ~',
+  'rm -rf *',
+  'git push --force',
+  'git reset --hard',
+  'DROP DATABASE',
+  'DROP TABLE',
+];
+
+async function beforeTool() {
+  const input = process.argv[2] ? JSON.parse(process.argv[2]) : {};
+  const toolName = input.tool || '';
+  const toolArgs = input.args || {};
+
+  const result = {
+    status: 'allow',
+    warnings: [],
+  };
+
+  // Check for file write operations
+  if (toolName === 'write_file' || toolName === 'replace') {
+    const content = toolArgs.content || toolArgs.new_content || '';
+
+    // Check for secrets
+    for (const pattern of BLOCKED_PATTERNS) {
+      if (pattern.test(content)) {
+        result.status = 'block';
+        result.message = 'Blocked: Potential secret or credential detected in content';
+        console.log(JSON.stringify(result));
+        process.exit(2); // Exit 2 = block
+      }
+    }
+
+    // Check for sensitive file paths
+    const filePath = toolArgs.path || toolArgs.file_path || '';
+    if (filePath.includes('.env') && !filePath.includes('.env.example')) {
+      result.warnings.push('Writing to .env file - ensure no secrets are committed');
+    }
+  }
+
+  // Check shell commands
+  if (toolName === 'shell' || toolName === 'bash' || toolName === 'execute') {
+    const command = toolArgs.command || '';
+
+    for (const dangerous of DANGEROUS_COMMANDS) {
+      if (command.toLowerCase().includes(dangerous.toLowerCase())) {
+        result.status = 'block';
+        result.message = `Blocked: Dangerous command detected: ${dangerous}`;
+        console.log(JSON.stringify(result));
+        process.exit(2);
+      }
+    }
+  }
+
+  // Log the tool execution for audit
+  logToolExecution(toolName, toolArgs);
+
+  console.log(JSON.stringify(result));
+  process.exit(0);
+}
+
+function logToolExecution(tool, args) {
+  try {
+    const projectDir = process.env.GEMINI_PROJECT_DIR || process.cwd();
+    const logDir = path.join(projectDir, '.aiox', 'logs');
+
+    if (!fs.existsSync(logDir)) {
+      fs.mkdirSync(logDir, { recursive: true });
+    }
+
+    const logEntry = {
+      timestamp: new Date().toISOString(),
+      tool,
+      argsKeys: Object.keys(args),
+      provider: 'gemini',
+    };
+
+    const logPath = path.join(logDir, 'tool-audit.jsonl');
+    fs.appendFileSync(logPath, JSON.stringify(logEntry) + '\n');
+  } catch (error) {
+    // Non-critical
+  }
+}
+
+// Execute
+beforeTool().catch((error) => {
+  console.log(JSON.stringify({ status: 'allow', error: error.message }));
+  process.exit(0);
+});

package/template/.aiox-core/hooks/gemini/rewind-handler.js

@@ -0,0 +1,68 @@
+#!/usr/bin/env node
+/**
+ * AIOX Rewind Handler
+ * Story GEMINI-INT.14 - /rewind Integration
+ *
+ * Syncs Gemini's /rewind command with AIOX state.
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+/**
+ * Sanitize sessionId to prevent path traversal
+ * Only allow alphanumeric, dash, and underscore
+ */
+function sanitizeSessionId(sessionId) {
+  if (!sessionId) return null;
+  // Remove any path separators and only keep safe characters
+  return sessionId.replace(/[^a-zA-Z0-9_-]/g, '');
+}
+
+async function handleRewind() {
+  const projectDir = process.env.GEMINI_PROJECT_DIR || process.cwd();
+  const rawSessionId = process.env.GEMINI_SESSION_ID;
+
+  // Sanitize sessionId to prevent path traversal
+  const sessionId = sanitizeSessionId(rawSessionId);
+
+  // Sync with AIOX memory layer
+  try {
+    const memoryDir = path.join(projectDir, '.aiox', 'memory');
+
+    if (fs.existsSync(memoryDir) && sessionId) {
+      // Clear session-specific memory (only if sessionId is valid)
+      const sessionMemory = path.join(memoryDir, `session-${sessionId}.json`);
+      // Verify the resolved path is still within memoryDir (defense in depth)
+      const resolvedPath = path.resolve(sessionMemory);
+      const resolvedMemoryDir = path.resolve(memoryDir);
+      if (resolvedPath.startsWith(resolvedMemoryDir) && fs.existsSync(sessionMemory)) {
+        fs.unlinkSync(sessionMemory);
+      }
+    }
+
+    // Log the rewind event
+    const logDir = path.join(projectDir, '.aiox', 'logs');
+    if (!fs.existsSync(logDir)) {
+      fs.mkdirSync(logDir, { recursive: true });
+    }
+
+    const rewindLog = {
+      timestamp: new Date().toISOString(),
+      sessionId,
+      action: 'rewind',
+      provider: 'gemini',
+    };
+
+    const logPath = path.join(logDir, 'rewind.jsonl');
+    fs.appendFileSync(logPath, JSON.stringify(rewindLog) + '\n');
+
+    console.log(JSON.stringify({ status: 'success', synced: true }));
+  } catch (error) {
+    console.log(JSON.stringify({ status: 'error', error: error.message }));
+  }
+
+  process.exit(0);
+}
+
+handleRewind();

package/template/.aiox-core/hooks/gemini/session-end.js

@@ -0,0 +1,90 @@
+#!/usr/bin/env node
+/**
+ * AIOX Session End Hook for Gemini CLI
+ * Story GEMINI-INT.6 - AIOX Hooks System
+ *
+ * Executes at session end to persist state to Memory Layer.
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+async function sessionEnd() {
+  const projectDir = process.env.GEMINI_PROJECT_DIR || process.cwd();
+  const sessionId = process.env.GEMINI_SESSION_ID || 'unknown';
+
+  // Persist session summary
+  try {
+    const sessionDir = path.join(projectDir, '.aiox', 'sessions');
+    if (!fs.existsSync(sessionDir)) {
+      fs.mkdirSync(sessionDir, { recursive: true });
+    }
+
+    // Load session files if tracked
+    let modifiedFiles = [];
+    const sessionFilesPath = path.join(projectDir, '.aiox', 'session-files.json');
+    if (fs.existsSync(sessionFilesPath)) {
+      modifiedFiles = JSON.parse(fs.readFileSync(sessionFilesPath, 'utf8'));
+      // Clean up
+      fs.unlinkSync(sessionFilesPath);
+    }
+
+    // Count tool executions
+    let toolCount = 0;
+    const toolLogPath = path.join(projectDir, '.aiox', 'logs', 'tool-results.jsonl');
+    if (fs.existsSync(toolLogPath)) {
+      const content = fs.readFileSync(toolLogPath, 'utf8');
+      toolCount = content.split('\n').filter((l) => l.includes(sessionId)).length;
+    }
+
+    // Create session summary
+    const summary = {
+      sessionId,
+      provider: 'gemini',
+      startedAt: process.env.GEMINI_SESSION_START || new Date().toISOString(),
+      endedAt: new Date().toISOString(),
+      filesModified: modifiedFiles.length,
+      toolExecutions: toolCount,
+      files: modifiedFiles,
+    };
+
+    // Save session
+    const sessionPath = path.join(sessionDir, `${sessionId}.json`);
+    fs.writeFileSync(sessionPath, JSON.stringify(summary, null, 2));
+
+    // Update recent sessions index
+    updateRecentSessions(sessionDir, sessionId);
+
+    console.log(JSON.stringify({ status: 'success', summary }));
+  } catch (error) {
+    console.log(JSON.stringify({ status: 'error', error: error.message }));
+  }
+
+  process.exit(0);
+}
+
+function updateRecentSessions(sessionDir, sessionId) {
+  try {
+    const indexPath = path.join(sessionDir, 'recent.json');
+    let recent = [];
+
+    if (fs.existsSync(indexPath)) {
+      recent = JSON.parse(fs.readFileSync(indexPath, 'utf8'));
+    }
+
+    // Add to front, keep last 20
+    recent.unshift({
+      sessionId,
+      timestamp: new Date().toISOString(),
+      provider: 'gemini',
+    });
+
+    recent = recent.slice(0, 20);
+
+    fs.writeFileSync(indexPath, JSON.stringify(recent, null, 2));
+  } catch (error) {
+    // Non-critical
+  }
+}
+
+sessionEnd();

package/template/.aiox-core/hooks/gemini/session-start.js

@@ -0,0 +1,90 @@
+#!/usr/bin/env node
+/**
+ * AIOX Session Start Hook for Gemini CLI
+ * Story GEMINI-INT.6 - AIOX Hooks System
+ *
+ * Executes at session start to load AIOX context and memory.
+ * Output must be valid JSON to stdout.
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+async function sessionStart() {
+  const projectDir = process.env.GEMINI_PROJECT_DIR || process.cwd();
+  const sessionId = process.env.GEMINI_SESSION_ID || `session-${Date.now()}`;
+
+  const result = {
+    status: 'success',
+    contextInjection: {
+      aioxVersion: '3.0',
+      sessionId,
+      projectType: detectProjectType(projectDir),
+      timestamp: new Date().toISOString(),
+    },
+  };
+
+  // Load project context if available
+  try {
+    const codebaseMapPath = path.join(projectDir, '.aiox', 'codebase-map.json');
+    if (fs.existsSync(codebaseMapPath)) {
+      const codebaseMap = JSON.parse(fs.readFileSync(codebaseMapPath, 'utf8'));
+      result.contextInjection.codebaseInfo = {
+        services: codebaseMap.services?.length || 0,
+        patterns: codebaseMap.patterns?.length || 0,
+        lastUpdated: codebaseMap.metadata?.lastUpdated,
+      };
+    }
+  } catch (error) {
+    // Non-critical, continue
+  }
+
+  // Load active story if any
+  try {
+    const storiesDir = path.join(projectDir, 'docs', 'stories', 'active');
+    if (fs.existsSync(storiesDir)) {
+      const stories = fs.readdirSync(storiesDir).filter((f) => f.endsWith('.md'));
+      if (stories.length > 0) {
+        result.contextInjection.activeStories = stories.length;
+      }
+    }
+  } catch (error) {
+    // Non-critical
+  }
+
+  return result;
+}
+
+function detectProjectType(projectDir) {
+  const packageJsonPath = path.join(projectDir, 'package.json');
+
+  if (fs.existsSync(packageJsonPath)) {
+    try {
+      const pkg = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
+      if (pkg.dependencies?.next || pkg.devDependencies?.next) return 'nextjs';
+      if (pkg.dependencies?.react || pkg.devDependencies?.react) return 'react';
+      if (pkg.dependencies?.express) return 'express';
+      if (pkg.dependencies?.['@nestjs/core']) return 'nestjs';
+      return 'node';
+    } catch {
+      return 'node';
+    }
+  }
+
+  if (fs.existsSync(path.join(projectDir, 'requirements.txt'))) return 'python';
+  if (fs.existsSync(path.join(projectDir, 'Cargo.toml'))) return 'rust';
+  if (fs.existsSync(path.join(projectDir, 'go.mod'))) return 'go';
+
+  return 'unknown';
+}
+
+// Execute and output JSON
+sessionStart()
+  .then((result) => {
+    console.log(JSON.stringify(result));
+    process.exit(0);
+  })
+  .catch((error) => {
+    console.log(JSON.stringify({ status: 'error', error: error.message }));
+    process.exit(0); // Exit 0 to not block Gemini
+  });