aios-core 2.1.0

package/.aios-core/elicitation/workflow-elicitation.js

@@ -0,0 +1,315 @@
+/**
+ * Workflow Creation Elicitation Workflow
+ * Progressive disclosure for creating new workflows
+ */
+
+const workflowElicitationSteps = [
+  {
+    title: 'Basic Workflow Information',
+    description: 'Define the core details of your workflow',
+    help: 'A workflow orchestrates multiple tasks and agents to achieve a complex goal.',
+    questions: [
+      {
+        type: 'input',
+        name: 'workflowId',
+        message: 'What is the workflow ID?',
+        examples: ['data-pipeline', 'release-process', 'quality-check'],
+        validate: (input) => {
+          if (!input) return 'Workflow ID is required';
+          if (!/^[a-z][a-z0-9-]*$/.test(input)) {
+            return 'ID must be lowercase with hyphens only';
+          }
+          return true;
+        },
+      },
+      {
+        type: 'input',
+        name: 'workflowName',
+        message: 'What is the workflow name?',
+        examples: ['Data Processing Pipeline', 'Software Release Process', 'Quality Assurance Workflow'],
+        smartDefault: {
+          type: 'fromAnswer',
+          source: 'workflowId',
+          transform: (id) => id.split('-').map(w => 
+            w.charAt(0).toUpperCase() + w.slice(1),
+          ).join(' '),
+        },
+      },
+      {
+        type: 'input',
+        name: 'workflowDescription',
+        message: 'Describe the workflow purpose:',
+        validate: (input) => input.length > 20 || 'Please provide a detailed description',
+      },
+      {
+        type: 'list',
+        name: 'workflowType',
+        message: 'What type of workflow is this?',
+        choices: [
+          { name: 'Sequential - Steps run one after another', value: 'sequential' },
+          { name: 'Parallel - Multiple steps can run simultaneously', value: 'parallel' },
+          { name: 'Conditional - Steps depend on conditions', value: 'conditional' },
+          { name: 'Hybrid - Mix of sequential and parallel', value: 'hybrid' },
+        ],
+        default: 'sequential',
+      },
+    ],
+    required: ['workflowId', 'workflowName', 'workflowDescription', 'workflowType'],
+  },
+
+  {
+    title: 'Workflow Triggers',
+    description: 'Define what starts this workflow',
+    questions: [
+      {
+        type: 'checkbox',
+        name: 'triggerTypes',
+        message: 'How can this workflow be triggered?',
+        choices: [
+          { name: 'Manual - User command', value: 'manual' },
+          { name: 'Schedule - Time-based', value: 'schedule' },
+          { name: 'Event - System event', value: 'event' },
+          { name: 'Webhook - External trigger', value: 'webhook' },
+          { name: 'File - File system change', value: 'file' },
+          { name: 'Completion - After another workflow', value: 'completion' },
+        ],
+        default: ['manual'],
+      },
+      {
+        type: 'input',
+        name: 'schedulePattern',
+        message: 'Enter schedule pattern (cron format):',
+        when: (answers) => answers.triggerTypes.includes('schedule'),
+        examples: ['0 9 * * *', '*/30 * * * *', '0 0 * * SUN'],
+        default: '0 9 * * *',
+      },
+      {
+        type: 'input',
+        name: 'eventTriggers',
+        message: 'Which events trigger this workflow? (comma-separated):',
+        when: (answers) => answers.triggerTypes.includes('event'),
+        examples: ['file.created', 'task.completed', 'error.detected'],
+        filter: (input) => input ? input.split(',').map(e => e.trim()) : [],
+      },
+    ],
+  },
+
+  {
+    title: 'Workflow Inputs',
+    description: 'Define input parameters for the workflow',
+    questions: [
+      {
+        type: 'confirm',
+        name: 'hasInputs',
+        message: 'Does this workflow require input parameters?',
+        default: true,
+      },
+      {
+        type: 'input',
+        name: 'inputCount',
+        message: 'How many input parameters?',
+        when: (answers) => answers.hasInputs,
+        default: '2',
+        validate: (input) => {
+          const num = parseInt(input);
+          return (num > 0 && num <= 10) || 'Please enter 1-10';
+        },
+        filter: (input) => parseInt(input),
+      },
+      // Note: Dynamic input collection would be implemented here
+      {
+        type: 'confirm',
+        name: 'validateInputs',
+        message: 'Add input validation rules?',
+        when: (answers) => answers.hasInputs,
+        default: true,
+      },
+    ],
+  },
+
+  {
+    title: 'Workflow Steps',
+    description: 'Define the steps in your workflow',
+    questions: [
+      {
+        type: 'input',
+        name: 'stepCount',
+        message: 'How many steps in this workflow?',
+        default: '3',
+        validate: (input) => {
+          const num = parseInt(input);
+          return (num > 0 && num <= 20) || 'Please enter 1-20';
+        },
+        filter: (input) => parseInt(input),
+      },
+      {
+        type: 'list',
+        name: 'stepDefinitionMethod',
+        message: 'How would you like to define steps?',
+        choices: [
+          { name: 'Quick mode - Basic step info only', value: 'quick' },
+          { name: 'Detailed mode - Full step configuration', value: 'detailed' },
+          { name: 'Import - Use existing task definitions', value: 'import' },
+        ],
+        default: 'quick',
+      },
+      // Note: Dynamic step collection would be implemented here
+    ],
+  },
+
+  {
+    title: 'Step Dependencies & Flow',
+    description: 'Configure how steps relate to each other',
+    condition: { field: 'workflowType', operator: 'notEquals', value: 'sequential' },
+    questions: [
+      {
+        type: 'confirm',
+        name: 'hasStepDependencies',
+        message: 'Do steps have dependencies on other steps?',
+        default: true,
+      },
+      {
+        type: 'confirm',
+        name: 'allowParallel',
+        message: 'Can some steps run in parallel?',
+        when: (answers) => answers.workflowType !== 'sequential',
+        default: true,
+      },
+      {
+        type: 'input',
+        name: 'maxParallel',
+        message: 'Maximum parallel executions:',
+        when: (answers) => answers.allowParallel,
+        default: '3',
+        validate: (input) => {
+          const num = parseInt(input);
+          return (num > 0 && num <= 10) || 'Please enter 1-10';
+        },
+      },
+    ],
+  },
+
+  {
+    title: 'Error Handling & Recovery',
+    description: 'Configure workflow error behavior',
+    questions: [
+      {
+        type: 'list',
+        name: 'globalErrorStrategy',
+        message: 'How should the workflow handle errors?',
+        choices: [
+          { name: 'Abort - Stop entire workflow on error', value: 'abort' },
+          { name: 'Continue - Log error and continue', value: 'continue' },
+          { name: 'Rollback - Undo completed steps', value: 'rollback' },
+          { name: 'Compensate - Run compensation steps', value: 'compensate' },
+        ],
+        default: 'abort',
+      },
+      {
+        type: 'confirm',
+        name: 'enableNotifications',
+        message: 'Send notifications on workflow events?',
+        default: true,
+      },
+      {
+        type: 'checkbox',
+        name: 'notificationEvents',
+        message: 'Which events should trigger notifications?',
+        when: (answers) => answers.enableNotifications,
+        choices: [
+          'Workflow started',
+          'Workflow completed',
+          'Workflow failed',
+          'Step failed',
+          'Waiting for input',
+          'Performance threshold exceeded',
+        ],
+        default: ['Workflow failed', 'Workflow completed'],
+      },
+    ],
+  },
+
+  {
+    title: 'Outputs & Results',
+    description: 'Define what the workflow produces',
+    questions: [
+      {
+        type: 'input',
+        name: 'outputDescription',
+        message: 'What does this workflow produce?',
+        examples: ['Processed data files', 'Deployment status report', 'Quality metrics'],
+        validate: (input) => input.length > 10 || 'Please describe the output',
+      },
+      {
+        type: 'checkbox',
+        name: 'outputTypes',
+        message: 'What types of output does it generate?',
+        choices: [
+          'Status report',
+          'Data files',
+          'Metrics/statistics',
+          'Logs',
+          'Notifications',
+          'Database updates',
+          'API responses',
+        ],
+      },
+      {
+        type: 'confirm',
+        name: 'saveOutputs',
+        message: 'Should outputs be saved for later reference?',
+        default: true,
+      },
+    ],
+    required: ['outputDescription'],
+  },
+
+  {
+    title: 'Security & Permissions',
+    description: 'Configure workflow security settings',
+    questions: [
+      {
+        type: 'confirm',
+        name: 'requireAuth',
+        message: 'Require authorization to run this workflow?',
+        default: false,
+      },
+      {
+        type: 'checkbox',
+        name: 'allowedRoles',
+        message: 'Which roles can execute this workflow?',
+        when: (answers) => answers.requireAuth,
+        choices: [
+          'admin',
+          'developer',
+          'analyst',
+          'reviewer',
+          'operator',
+          'viewer',
+        ],
+        default: ['admin', 'developer'],
+      },
+      {
+        type: 'confirm',
+        name: 'enableAuditLog',
+        message: 'Enable audit logging for this workflow?',
+        default: true,
+      },
+      {
+        type: 'checkbox',
+        name: 'securityFeatures',
+        message: 'Additional security features:',
+        choices: [
+          'Encrypt sensitive data',
+          'Mask credentials in logs',
+          'Validate all inputs',
+          'Sandbox execution',
+          'Rate limiting',
+        ],
+        when: (answers) => answers.requireAuth,
+      },
+    ],
+  },
+];
+
+module.exports = workflowElicitationSteps;

package/.aios-core/index.d.ts

@@ -0,0 +1,8 @@
+// @aios-fullstack/core - TypeScript Definitions
+export declare const MetaAgent: any;
+export declare const TaskManager: any;
+export declare const ElicitationEngine: any;
+export declare const TemplateEngine: any;
+export declare const ComponentSearch: any;
+export declare const DependencyAnalyzer: any;
+export {};

package/.aios-core/index.esm.js

@@ -0,0 +1,16 @@
+// @aios-fullstack/core - ES Module Entry Point
+import MetaAgent from './utils/component-generator.js';
+import TaskManager from './utils/batch-creator.js';
+import ElicitationEngine from './utils/elicitation-engine.js';
+import TemplateEngine from './utils/template-engine.js';
+import ComponentSearch from './utils/component-search.js';
+import DependencyAnalyzer from './utils/dependency-analyzer.js';
+
+export {
+    MetaAgent,
+    TaskManager,
+    ElicitationEngine,
+    TemplateEngine,
+    ComponentSearch,
+    DependencyAnalyzer
+};

package/.aios-core/index.js

@@ -0,0 +1,16 @@
+// @aios-fullstack/core - CommonJS Entry Point
+const MetaAgent = require('./infrastructure/scripts/component-generator.js');
+const TaskManager = require('./infrastructure/scripts/batch-creator.js');
+const ElicitationEngine = require('./scripts/elicitation-engine.js');
+const TemplateEngine = require('./infrastructure/scripts/template-engine.js');
+const ComponentSearch = require('./infrastructure/scripts/component-search.js');
+const DependencyAnalyzer = require('./infrastructure/scripts/dependency-analyzer.js');
+
+module.exports = {
+  MetaAgent: MetaAgent,
+  TaskManager: TaskManager,
+  ElicitationEngine: ElicitationEngine,
+  TemplateEngine: TemplateEngine,
+  ComponentSearch: ComponentSearch,
+  DependencyAnalyzer: DependencyAnalyzer,
+};

package/.aios-core/infrastructure/README.md

@@ -0,0 +1,126 @@
+# Infrastructure Module
+
+Base layer of the AIOS modular architecture. Contains tools, integrations, scripts, and PM adapters.
+
+## Structure
+
+```
+infrastructure/
+├── tools/                      # Tool configurations (14 files)
+│   ├── cli/                    # CLI tools (github-cli, railway-cli, supabase-cli)
+│   ├── local/                  # Local tools (ffmpeg)
+│   ├── mcp/                    # MCP tools (9 configs)
+│   └── README.md
+│
+├── scripts/                    # Infrastructure scripts (50+)
+│   ├── _archived/              # Archived migration scripts
+│   └── *.js                    # Active infrastructure scripts
+│
+├── integrations/               # External integrations
+│   └── pm-adapters/            # PM tool adapters (4 adapters)
+│
+├── tests/                      # Test utilities
+│   ├── project-status-loader.test.js
+│   └── regression-suite-v2.md
+│
+├── index.js                    # Module exports
+└── README.md                   # This file
+```
+
+## Dependency Direction
+
+Infrastructure is the **base layer** - it has no dependencies on other modules:
+
+```
+infrastructure/ ← core/ ← development/ ← product/
+```
+
+- `infrastructure/` CAN import from: nothing (base layer)
+- `core/` CAN import from: `infrastructure/`
+- `development/` CAN import from: `infrastructure/`, `core/`
+- `product/` CAN import from: `infrastructure/`, `core/`
+
+## Key Components
+
+### Git Integration
+- `GitWrapper` - Git CLI wrapper for all git operations
+- `GitConfigDetector` - Detects git configuration status
+- `BranchManager` - Branch management utilities
+- `CommitMessageGenerator` - Generates commit messages
+
+### PM Integration
+- `getPMAdapter()` - Factory for PM tool adapters
+- `PMAdapter` - Base adapter class
+- Adapters: ClickUp, GitHub Projects, Jira, Local (standalone)
+
+### Template & Generation
+- `TemplateEngine` - Template rendering
+- `ComponentGenerator` - AIOS component generation
+- `BatchCreator` - Batch operations
+
+### Validation
+- `AiosValidator` - AIOS component validation
+- `TemplateValidator` - Template validation
+- `SpotCheckValidator` - Spot check validation
+
+### Analysis
+- `DependencyAnalyzer` - Dependency analysis
+- `SecurityChecker` - Security validation
+- `CapabilityAnalyzer` - Capability analysis
+
+### Testing
+- `TestGenerator` - Test file generation
+- `CoverageAnalyzer` - Coverage analysis
+- `SandboxTester` - Sandbox testing
+
+### Performance
+- `PerformanceAnalyzer` - Performance analysis
+- `PerformanceTracker` - Performance tracking
+- `PerformanceOptimizer` - Performance optimization
+
+### Quality
+- `CodeQualityImprover` - Code quality improvements
+- `RefactoringSuggester` - Refactoring suggestions
+- `ImprovementEngine` - General improvements
+
+## Usage
+
+```javascript
+// Import from infrastructure module
+const {
+  GitWrapper,
+  getPMAdapter,
+  TemplateEngine,
+  resolveTool
+} = require('.aios-core/infrastructure');
+
+// Or import directly from scripts
+const GitWrapper = require('.aios-core/infrastructure/scripts/git-wrapper');
+```
+
+## Tool Resolution
+
+```javascript
+const { resolveTool } = require('.aios-core/infrastructure');
+
+// Get tool configuration
+const clickupTool = await resolveTool('clickup');
+const githubCli = await resolveTool('github-cli');
+```
+
+## PM Adapters
+
+```javascript
+const { getPMAdapter, isPMToolConfigured } = require('.aios-core/infrastructure');
+
+// Check if PM tool is configured
+if (isPMToolConfigured()) {
+  const adapter = getPMAdapter();
+  await adapter.syncStory(storyPath);
+}
+```
+
+## Migration Reference
+
+Created as part of Story 2.5 - Infrastructure Module Creation.
+See [ADR-002 Migration Map](../../docs/architecture/decisions/ADR-002-migration-map.md).

package/.aios-core/infrastructure/index.js

@@ -0,0 +1,199 @@
+/**
+ * @fileoverview Infrastructure Module - Entry Point
+ *
+ * Centralizes tools, integrations, scripts, and PM adapters.
+ * This is the base layer of the AIOS modular architecture.
+ *
+ * Uses safe loading to handle optional dependencies gracefully.
+ *
+ * @module infrastructure
+ * @see ADR-002 Migration Map
+ */
+
+/**
+ * Safely require a module, returning null if it fails
+ */
+function safeRequire(modulePath) {
+  try {
+    return require(modulePath);
+  } catch (error) {
+    // Only log in debug mode to avoid noise
+    if (process.env.AIOS_DEBUG) {
+      console.warn(`[infrastructure] Failed to load ${modulePath}: ${error.message}`);
+    }
+    return null;
+  }
+}
+
+// Git Integration
+const GitWrapper = safeRequire('./scripts/git-wrapper');
+const GitConfigDetector = safeRequire('./scripts/git-config-detector');
+const BranchManager = safeRequire('./scripts/branch-manager');
+const CommitMessageGenerator = safeRequire('./scripts/commit-message-generator');
+
+// PM Integration
+const pmAdapter = safeRequire('./scripts/pm-adapter');
+const PMAdapter = pmAdapter ? pmAdapter.PMAdapter : null;
+const pmFactory = safeRequire('./scripts/pm-adapter-factory');
+const getPMAdapter = pmFactory ? pmFactory.getPMAdapter : null;
+const isPMToolConfigured = pmFactory ? pmFactory.isPMToolConfigured : null;
+const clearPMAdapterCache = pmFactory ? pmFactory.clearPMAdapterCache : null;
+const StatusMapper = safeRequire('./scripts/status-mapper');
+const ClickUpHelpers = safeRequire('./scripts/clickup-helpers');
+
+// Template & Generation
+const TemplateEngine = safeRequire('./scripts/template-engine');
+const ComponentGenerator = safeRequire('./scripts/component-generator');
+const ComponentMetadata = safeRequire('./scripts/component-metadata');
+const ComponentSearch = safeRequire('./scripts/component-search');
+const BatchCreator = safeRequire('./scripts/batch-creator');
+
+// Validation
+const AiosValidator = safeRequire('./scripts/aios-validator');
+const TemplateValidator = safeRequire('./scripts/template-validator');
+const validateOutputPatternModule = safeRequire('./scripts/validate-output-pattern');
+const validateOutputPattern = validateOutputPatternModule ? validateOutputPatternModule.validateOutputPattern : null;
+const SpotCheckValidator = safeRequire('./scripts/spot-check-validator');
+
+// Analysis
+const DependencyAnalyzer = safeRequire('./scripts/dependency-analyzer');
+const DependencyImpactAnalyzer = safeRequire('./scripts/dependency-impact-analyzer');
+const FrameworkAnalyzer = safeRequire('./scripts/framework-analyzer');
+const CapabilityAnalyzer = safeRequire('./scripts/capability-analyzer');
+const SecurityChecker = safeRequire('./scripts/security-checker');
+const ModificationRiskAssessment = safeRequire('./scripts/modification-risk-assessment');
+
+// Testing
+const CoverageAnalyzer = safeRequire('./scripts/coverage-analyzer');
+const TestGenerator = safeRequire('./scripts/test-generator');
+const TestUtilities = safeRequire('./scripts/test-utilities');
+const TestUtilitiesFast = safeRequire('./scripts/test-utilities-fast');
+const TestQualityAssessment = safeRequire('./scripts/test-quality-assessment');
+const SandboxTester = safeRequire('./scripts/sandbox-tester');
+
+// Performance
+const PerformanceAnalyzer = safeRequire('./scripts/performance-analyzer');
+const PerformanceOptimizer = safeRequire('./scripts/performance-optimizer');
+const PerformanceTracker = safeRequire('./scripts/performance-tracker');
+const PerformanceAndErrorResolver = safeRequire('./scripts/performance-and-error-resolver');
+
+// Quality
+const CodeQualityImprover = safeRequire('./scripts/code-quality-improver');
+const RefactoringSuggester = safeRequire('./scripts/refactoring-suggester');
+const ImprovementEngine = safeRequire('./scripts/improvement-engine');
+const ImprovementValidator = safeRequire('./scripts/improvement-validator');
+const ModificationValidator = safeRequire('./scripts/modification-validator');
+
+// Utilities
+const ConflictResolver = safeRequire('./scripts/conflict-resolver');
+const DocumentationSynchronizer = safeRequire('./scripts/documentation-synchronizer');
+const toolResolver = safeRequire('./scripts/tool-resolver');
+const resolveTool = toolResolver ? toolResolver.resolveTool : null;
+const UsageAnalytics = safeRequire('./scripts/usage-analytics');
+const projectStatusLoader = safeRequire('./scripts/project-status-loader');
+const loadProjectStatus = projectStatusLoader ? projectStatusLoader.loadProjectStatus : null;
+const formatStatusDisplay = projectStatusLoader ? projectStatusLoader.formatStatusDisplay : null;
+const VisualImpactGenerator = safeRequire('./scripts/visual-impact-generator');
+const AtomicLayerClassifier = safeRequire('./scripts/atomic-layer-classifier');
+
+// System
+const BackupManager = safeRequire('./scripts/backup-manager');
+const TransactionManager = safeRequire('./scripts/transaction-manager');
+const RepositoryDetector = safeRequire('./scripts/repository-detector');
+const ApprovalWorkflow = safeRequire('./scripts/approval-workflow');
+
+// Config
+const ConfigCache = safeRequire('./scripts/config-cache');
+const ConfigLoader = safeRequire('./scripts/config-loader');
+const OutputFormatter = safeRequire('./scripts/output-formatter');
+const YamlValidator = safeRequire('./scripts/yaml-validator');
+
+// Build exports object, filtering out null values
+const moduleExports = {
+  // Git Integration
+  GitWrapper,
+  GitConfigDetector,
+  BranchManager,
+  CommitMessageGenerator,
+
+  // PM Integration
+  PMAdapter,
+  getPMAdapter,
+  isPMToolConfigured,
+  clearPMAdapterCache,
+  StatusMapper,
+  ClickUpHelpers,
+
+  // Template & Generation
+  TemplateEngine,
+  ComponentGenerator,
+  ComponentMetadata,
+  ComponentSearch,
+  BatchCreator,
+
+  // Validation
+  AiosValidator,
+  TemplateValidator,
+  validateOutputPattern,
+  SpotCheckValidator,
+
+  // Analysis
+  DependencyAnalyzer,
+  DependencyImpactAnalyzer,
+  FrameworkAnalyzer,
+  CapabilityAnalyzer,
+  SecurityChecker,
+  ModificationRiskAssessment,
+
+  // Testing
+  CoverageAnalyzer,
+  TestGenerator,
+  TestUtilities,
+  TestUtilitiesFast,
+  TestQualityAssessment,
+  SandboxTester,
+
+  // Performance
+  PerformanceAnalyzer,
+  PerformanceOptimizer,
+  PerformanceTracker,
+  PerformanceAndErrorResolver,
+
+  // Quality
+  CodeQualityImprover,
+  RefactoringSuggester,
+  ImprovementEngine,
+  ImprovementValidator,
+  ModificationValidator,
+
+  // Utilities
+  ConflictResolver,
+  DocumentationSynchronizer,
+  resolveTool,
+  UsageAnalytics,
+  loadProjectStatus,
+  formatStatusDisplay,
+  VisualImpactGenerator,
+  AtomicLayerClassifier,
+
+  // System
+  BackupManager,
+  TransactionManager,
+  RepositoryDetector,
+  ApprovalWorkflow,
+
+  // Config
+  ConfigCache,
+  ConfigLoader,
+  OutputFormatter,
+  YamlValidator,
+};
+
+// Remove null exports for cleaner API
+Object.keys(moduleExports).forEach(key => {
+  if (moduleExports[key] === null) {
+    delete moduleExports[key];
+  }
+});
+
+module.exports = moduleExports;