telos-framework 0.1.0

package/lib/commands/init.js

@@ -0,0 +1,112 @@
+const chalk = require('chalk');
+const ora = require('ora');
+const path = require('path');
+const { discoverTelos } = require('../discovery/telos-discovery');
+const { buildHierarchy } = require('../discovery/hierarchy-builder');
+const { generateTelosMd } = require('../generators/telos-md-generator');
+const { generateL9Agent, generateL1Agent, generateL2Agent } = require('../generators/agent-generator');
+const { generateAllAgents } = require('../generators/all-agents-generator');
+const { scanProject } = require('../discovery/code-scanner');
+const { discoverMcpServers, mapMcpToCapabilities } = require('../discovery/mcp-discovery');
+const { mapToolsToLevels, getToolRecommendations } = require('../discovery/tool-mapper');
+const { generateToolsMd } = require('../generators/tools-md-generator');
+const { generateLogosMd } = require('../generators/logos-md-generator');
+const { consolidateAgents } = require('../generators/agents-md-generator');
+const { detectPlatforms, getPlatformConfig } = require('../platform/platform-detector');
+const { createSymlinks } = require('../platform/symlink-creator');
+
+async function initCommand(options) {
+  console.log(chalk.bold.cyan('\n╔════════════════════════════════════════╗'));
+  console.log(chalk.bold.cyan('║   Telos Multi-Agent Initialization   ║'));
+  console.log(chalk.bold.cyan('╚════════════════════════════════════════╝\n'));
+
+  try {
+    const telosData = await discoverTelos(options);
+    
+    const spinner = ora('Building purpose hierarchy...').start();
+    const hierarchy = await buildHierarchy(telosData, options);
+    spinner.succeed('Purpose hierarchy built');
+
+    spinner.start('Generating TELOS.md...');
+    const telosPath = path.join(process.cwd(), 'telos', 'content', 'TELOS.md');
+    await generateTelosMd(hierarchy, telosPath);
+    spinner.succeed(`Generated ${telosPath}`);
+
+    spinner.start('Generating L9 Telos-Guardian agent...');
+    const l9AgentPath = path.join(process.cwd(), 'telos', 'agents', 'l9-telos-guardian.md');
+    await generateL9Agent(hierarchy, l9AgentPath);
+    spinner.succeed(`Generated ${l9AgentPath}`);
+
+    console.log(chalk.green('\n✓ Phase 1: Telos Discovery Complete\n'));
+
+    spinner.start('Scanning project for tools and frameworks...');
+    const projectScan = await scanProject(process.cwd());
+    spinner.succeed('Project scan complete');
+
+    spinner.start('Discovering MCP servers...');
+    const mcpServers = await discoverMcpServers();
+    const mcpCapabilities = mapMcpToCapabilities(mcpServers);
+    spinner.succeed(`Found ${mcpServers.length} MCP server(s)`);
+
+    spinner.start('Mapping tools to agent levels...');
+    const levelTools = mapToolsToLevels(projectScan, mcpCapabilities);
+    const recommendations = getToolRecommendations(levelTools);
+    spinner.succeed('Tool mapping complete');
+
+    spinner.start('Generating TOOLS.md...');
+    const toolsPath = path.join(process.cwd(), 'telos', 'content', 'TOOLS.md');
+    await generateToolsMd(levelTools, projectScan, mcpServers, recommendations, toolsPath);
+    spinner.succeed(`Generated ${toolsPath}`);
+
+    console.log(chalk.green('\n✓ Phase 2: Tool Discovery Complete\n'));
+
+    spinner.start('Generating all agent definitions...');
+    const agentsDir = path.join(process.cwd(), 'telos', 'agents');
+    
+    await generateL1Agent(hierarchy, levelTools.L1.tools, path.join(agentsDir, 'l1-syntax-linter.md'));
+    await generateL2Agent(hierarchy, levelTools.L2.tools, path.join(agentsDir, 'l2-function-author.md'));
+    await generateAllAgents(hierarchy, levelTools, agentsDir);
+    
+    spinner.succeed('Generated all 9 agent definitions');
+
+    console.log(chalk.green('\n✓ Phase 3: Agent Generation Complete\n'));
+
+    spinner.start('Generating Logos orchestrator documentation...');
+    const logosPath = path.join(process.cwd(), 'telos', 'content', 'LOGOS.md');
+    await generateLogosMd(logosPath);
+    spinner.succeed(`Generated ${logosPath}`);
+
+    console.log(chalk.green('\n✓ Phase 4: Logos Orchestrator Complete\n'));
+
+    spinner.start('Consolidating agents into AGENTS.md...');
+    const agentsMdPath = path.join(process.cwd(), 'telos', 'content', 'AGENTS.md');
+    await consolidateAgents(agentsDir, agentsMdPath);
+    spinner.succeed(`Generated ${agentsMdPath}`);
+
+    spinner.start('Detecting platforms and creating symlinks...');
+    const platforms = await detectPlatforms(process.cwd());
+    let symlinkCount = 0;
+    
+    for (const platform of platforms) {
+      const config = getPlatformConfig(platform.name);
+      const results = await createSymlinks(process.cwd(), config);
+      symlinkCount += results.filter(r => r.success).length;
+    }
+    
+    spinner.succeed(`Created ${symlinkCount} platform symlink(s) for ${platforms.map(p => p.name).join(', ')}`);
+
+    console.log(chalk.green('\n✓ Phase 5: Platform Configuration Complete\n'));
+    
+    console.log(chalk.cyan('Your Telos has been captured in:'));
+    console.log(chalk.bold(`  ${telosPath}\n`));
+
+  } catch (error) {
+    console.error(chalk.red('\n✗ Initialization failed:'), error.message);
+    if (options.verbose) {
+      console.error(error);
+    }
+    process.exit(1);
+  }
+}
+
+module.exports = { initCommand };

package/lib/commands/rediscover.js

@@ -0,0 +1,48 @@
+const chalk = require('chalk');
+const ora = require('ora');
+const path = require('path');
+const { scanProject } = require('../discovery/code-scanner');
+const { discoverMcpServers, mapMcpToCapabilities } = require('../discovery/mcp-discovery');
+const { mapToolsToLevels, getToolRecommendations } = require('../discovery/tool-mapper');
+const { generateToolsMd } = require('../generators/tools-md-generator');
+
+async function rediscoverCommand(options) {
+  console.log(chalk.cyan('\n=== Tool Rediscovery ===\n'));
+
+  try {
+    const spinner = ora('Re-scanning project...').start();
+    const projectScan = await scanProject(process.cwd());
+    spinner.succeed('Project scan complete');
+
+    spinner.start('Re-discovering MCP servers...');
+    const mcpServers = await discoverMcpServers();
+    const mcpCapabilities = mapMcpToCapabilities(mcpServers);
+    spinner.succeed(`Found ${mcpServers.length} MCP server(s)`);
+
+    spinner.start('Re-mapping tools to agent levels...');
+    const levelTools = mapToolsToLevels(projectScan, mcpCapabilities);
+    const recommendations = getToolRecommendations(levelTools);
+    spinner.succeed('Tool mapping complete');
+
+    spinner.start('Updating TOOLS.md...');
+    const toolsPath = path.join(process.cwd(), 'telos', 'content', 'TOOLS.md');
+    await generateToolsMd(levelTools, projectScan, mcpServers, recommendations, toolsPath);
+    spinner.succeed(`Updated ${toolsPath}`);
+
+    console.log(chalk.green('\n✓ Tool rediscovery complete\n'));
+
+    if (recommendations.length > 0) {
+      console.log(chalk.yellow('Recommendations:'));
+      for (const rec of recommendations) {
+        console.log(chalk.dim(`  [${rec.level}] ${rec.message}`));
+      }
+      console.log();
+    }
+
+  } catch (error) {
+    console.error(chalk.red('\n✗ Rediscovery failed:'), error.message);
+    process.exit(1);
+  }
+}
+
+module.exports = { rediscoverCommand };

package/lib/commands/status.js

@@ -0,0 +1,77 @@
+const chalk = require('chalk');
+const fs = require('fs').promises;
+const path = require('path');
+
+async function statusCommand(options) {
+  console.log(chalk.cyan('\n=== Telos Status ===\n'));
+
+  try {
+    const telosPath = path.join(process.cwd(), 'telos', 'content', 'TELOS.md');
+    const toolsPath = path.join(process.cwd(), 'telos', 'content', 'TOOLS.md');
+    const agentsPath = path.join(process.cwd(), 'telos', 'content', 'AGENTS.md');
+    const configPath = path.join(process.cwd(), '.telos', 'config.json');
+    
+    let initialized = false;
+    let config = null;
+
+    try {
+      await fs.access(telosPath);
+      initialized = true;
+      console.log(chalk.green('✓ Telos initialized'));
+      console.log(chalk.dim(`  Location: ${telosPath}\n`));
+    } catch {
+      console.log(chalk.yellow('✗ Telos not initialized'));
+      console.log(chalk.dim('  Run: telos init\n'));
+      return;
+    }
+
+    try {
+      const configContent = await fs.readFile(configPath, 'utf8');
+      config = JSON.parse(configContent);
+    } catch {
+    }
+
+    console.log(chalk.cyan('Components:'));
+    
+    try {
+      await fs.access(agentsPath);
+      const agentFiles = await fs.readdir(path.join(process.cwd(), 'telos', 'agents'));
+      console.log(chalk.green(`  ✓ Agents: ${agentFiles.length} configured`));
+    } catch {
+      console.log(chalk.yellow('  ✗ Agents: Not configured'));
+    }
+
+    try {
+      await fs.access(toolsPath);
+      const toolsContent = await fs.readFile(toolsPath, 'utf8');
+      const toolCount = (toolsContent.match(/^- \*\*/gm) || []).length;
+      console.log(chalk.green(`  ✓ Tools: ${toolCount} discovered`));
+    } catch {
+      console.log(chalk.yellow('  ✗ Tools: Not discovered'));
+    }
+
+    if (config) {
+      console.log(chalk.green(`  ✓ Platform: ${config.platform || 'generic'}`));
+      console.log(chalk.green(`  ✓ Initialized: ${new Date(config.timestamp).toLocaleString()}\n`));
+    } else {
+      console.log(chalk.yellow('  ✗ Configuration: Not found\n'));
+    }
+
+    if (options.verbose) {
+      console.log(chalk.cyan('Telos Hierarchy:'));
+      try {
+        const telosContent = await fs.readFile(telosPath, 'utf8');
+        const lines = telosContent.split('\n').slice(0, 20);
+        console.log(chalk.dim(lines.join('\n')));
+      } catch (error) {
+        console.log(chalk.red('  Error reading Telos content'));
+      }
+    }
+
+  } catch (error) {
+    console.error(chalk.red('Error checking status:'), error.message);
+    process.exit(1);
+  }
+}
+
+module.exports = { statusCommand };

package/lib/commands/validate.js

@@ -0,0 +1,148 @@
+const chalk = require('chalk');
+const fs = require('fs').promises;
+const path = require('path');
+
+async function validateCommand(options) {
+  console.log(chalk.cyan('\n=== Telos Validation ===\n'));
+
+  try {
+    const telosPath = path.join(process.cwd(), 'telos', 'content', 'TELOS.md');
+    
+    try {
+      await fs.access(telosPath);
+    } catch {
+      console.log(chalk.red('✗ Telos not initialized'));
+      console.log(chalk.dim('  Run: telos init first\n'));
+      return;
+    }
+
+    const checks = [
+      { name: 'Telos Hierarchy', fn: validateTelosHierarchy },
+      { name: 'Agent Definitions', fn: validateAgents },
+      { name: 'Tool Configuration', fn: validateTools },
+      { name: 'Platform Setup', fn: validatePlatform }
+    ];
+
+    let passed = 0;
+    let failed = 0;
+
+    for (const check of checks) {
+      try {
+        const result = await check.fn(process.cwd());
+        if (result.valid) {
+          console.log(chalk.green(`✓ ${check.name}`));
+          if (result.details && options.verbose) {
+            console.log(chalk.dim(`  ${result.details}`));
+          }
+          passed++;
+        } else {
+          console.log(chalk.yellow(`✗ ${check.name}`));
+          if (result.message) {
+            console.log(chalk.dim(`  ${result.message}`));
+          }
+          failed++;
+        }
+      } catch (error) {
+        console.log(chalk.red(`✗ ${check.name}`));
+        console.log(chalk.dim(`  Error: ${error.message}`));
+        failed++;
+      }
+    }
+
+    console.log(chalk.cyan(`\nResults: ${passed} passed, ${failed} failed\n`));
+
+    if (failed > 0) {
+      process.exit(1);
+    }
+
+  } catch (error) {
+    console.error(chalk.red('Error during validation:'), error.message);
+    process.exit(1);
+  }
+}
+
+async function validateTelosHierarchy(projectRoot) {
+  const telosPath = path.join(projectRoot, 'telos', 'content', 'TELOS.md');
+  
+  try {
+    const content = await fs.readFile(telosPath, 'utf8');
+    
+    const hasL9 = content.includes('## L9:');
+    const hasL1 = content.includes('## L1:');
+    
+    if (hasL9 && hasL1) {
+      const levelCount = (content.match(/## L\d:/g) || []).length;
+      return {
+        valid: levelCount >= 5,
+        details: `${levelCount} levels defined`
+      };
+    }
+    
+    return {
+      valid: false,
+      message: 'Missing level definitions'
+    };
+  } catch (error) {
+    return {
+      valid: false,
+      message: 'Could not read TELOS.md'
+    };
+  }
+}
+
+async function validateAgents(projectRoot) {
+  const agentsPath = path.join(projectRoot, 'telos', 'agents');
+  
+  try {
+    const files = await fs.readdir(agentsPath);
+    const agentFiles = files.filter(f => f.endsWith('.md'));
+    
+    return {
+      valid: agentFiles.length >= 9,
+      details: `${agentFiles.length} agent files found`
+    };
+  } catch (error) {
+    return {
+      valid: false,
+      message: 'Agents directory not found'
+    };
+  }
+}
+
+async function validateTools(projectRoot) {
+  const toolsPath = path.join(projectRoot, 'telos', 'content', 'TOOLS.md');
+  
+  try {
+    const content = await fs.readFile(toolsPath, 'utf8');
+    const hasToolSection = content.includes('## Tools by Agent Level');
+    
+    return {
+      valid: hasToolSection,
+      details: 'Tool inventory present'
+    };
+  } catch (error) {
+    return {
+      valid: false,
+      message: 'TOOLS.md not found'
+    };
+  }
+}
+
+async function validatePlatform(projectRoot) {
+  const agentsPath = path.join(projectRoot, 'telos', 'content', 'AGENTS.md');
+  
+  try {
+    await fs.access(agentsPath);
+    return {
+      valid: true,
+      details: 'AGENTS.md exists'
+    };
+  } catch (error) {
+    return {
+      valid: false,
+      message: 'AGENTS.md not found - run platform setup'
+    };
+  }
+}
+
+module.exports = { validateCommand };

package/lib/discovery/code-scanner.js

@@ -0,0 +1,129 @@
+const fs = require('fs').promises;
+const path = require('path');
+
+async function scanProject(projectRoot) {
+  const results = {
+    languages: new Set(),
+    frameworks: new Set(),
+    testFrameworks: new Set(),
+    linters: new Set(),
+    buildTools: new Set(),
+    packageManagers: new Set()
+  };
+
+  try {
+    const files = await fs.readdir(projectRoot);
+    
+    for (const file of files) {
+      if (file.startsWith('.')) continue;
+      
+      const filePath = path.join(projectRoot, file);
+      const stat = await fs.stat(filePath);
+      
+      if (stat.isFile()) {
+        await detectFromFile(file, filePath, results);
+      }
+    }
+
+    await detectFromPackageJson(projectRoot, results);
+    
+  } catch (error) {
+    console.error('Error scanning project:', error.message);
+  }
+
+  return {
+    languages: Array.from(results.languages),
+    frameworks: Array.from(results.frameworks),
+    testFrameworks: Array.from(results.testFrameworks),
+    linters: Array.from(results.linters),
+    buildTools: Array.from(results.buildTools),
+    packageManagers: Array.from(results.packageManagers)
+  };
+}
+
+async function detectFromFile(filename, filePath, results) {
+  if (filename === 'package.json') {
+    results.packageManagers.add('npm');
+    results.languages.add('JavaScript/TypeScript');
+  } else if (filename === 'package-lock.json') {
+    results.packageManagers.add('npm');
+  } else if (filename === 'yarn.lock') {
+    results.packageManagers.add('yarn');
+  } else if (filename === 'pnpm-lock.yaml') {
+    results.packageManagers.add('pnpm');
+  } else if (filename === 'Cargo.toml') {
+    results.languages.add('Rust');
+    results.packageManagers.add('cargo');
+  } else if (filename === 'go.mod') {
+    results.languages.add('Go');
+    results.packageManagers.add('go modules');
+  } else if (filename === 'requirements.txt' || filename === 'pyproject.toml') {
+    results.languages.add('Python');
+    results.packageManagers.add('pip');
+  } else if (filename === 'Gemfile') {
+    results.languages.add('Ruby');
+    results.packageManagers.add('bundler');
+  } else if (filename === 'pubspec.yaml') {
+    results.languages.add('Dart');
+    results.frameworks.add('Flutter');
+    results.packageManagers.add('pub');
+  } else if (filename === '.eslintrc.js' || filename === '.eslintrc.json' || filename === 'eslint.config.js') {
+    results.linters.add('ESLint');
+  } else if (filename === '.prettierrc' || filename === '.prettierrc.json') {
+    results.linters.add('Prettier');
+  } else if (filename === 'ruff.toml' || filename === '.ruff.toml') {
+    results.linters.add('Ruff');
+  } else if (filename === 'vite.config.js' || filename === 'vite.config.ts') {
+    results.buildTools.add('Vite');
+  } else if (filename === 'webpack.config.js') {
+    results.buildTools.add('Webpack');
+  } else if (filename === 'vitest.config.js' || filename === 'vitest.config.ts') {
+    results.testFrameworks.add('Vitest');
+  } else if (filename === 'jest.config.js' || filename === 'jest.config.json') {
+    results.testFrameworks.add('Jest');
+  } else if (filename === 'playwright.config.js' || filename === 'playwright.config.ts') {
+    results.testFrameworks.add('Playwright');
+  } else if (filename === 'cypress.config.js' || filename === 'cypress.config.ts') {
+    results.testFrameworks.add('Cypress');
+  }
+}
+
+async function detectFromPackageJson(projectRoot, results) {
+  try {
+    const pkgPath = path.join(projectRoot, 'package.json');
+    const content = await fs.readFile(pkgPath, 'utf8');
+    const pkg = JSON.parse(content);
+    
+    const allDeps = {
+      ...pkg.dependencies,
+      ...pkg.devDependencies
+    };
+
+    if (allDeps.react) results.frameworks.add('React');
+    if (allDeps.vue) results.frameworks.add('Vue');
+    if (allDeps.next) results.frameworks.add('Next.js');
+    if (allDeps.nuxt) results.frameworks.add('Nuxt');
+    if (allDeps.svelte) results.frameworks.add('Svelte');
+    if (allDeps['@angular/core']) results.frameworks.add('Angular');
+    if (allDeps.express) results.frameworks.add('Express');
+    if (allDeps.fastify) results.frameworks.add('Fastify');
+    if (allDeps.nest) results.frameworks.add('NestJS');
+    
+    if (allDeps.vitest) results.testFrameworks.add('Vitest');
+    if (allDeps.jest) results.testFrameworks.add('Jest');
+    if (allDeps.mocha) results.testFrameworks.add('Mocha');
+    if (allDeps.playwright) results.testFrameworks.add('Playwright');
+    if (allDeps.cypress) results.testFrameworks.add('Cypress');
+    
+    if (allDeps.eslint) results.linters.add('ESLint');
+    if (allDeps.prettier) results.linters.add('Prettier');
+    if (allDeps.typescript) {
+      results.languages.add('TypeScript');
+      results.linters.add('TypeScript Compiler');
+    }
+    
+  } catch (error) {
+  }
+}
+
+module.exports = { scanProject };

package/lib/discovery/hierarchy-builder.js

@@ -0,0 +1,147 @@
+const inquirer = require('inquirer');
+const chalk = require('chalk');
+
+const LEVEL_DESCRIPTIONS = {
+  L9: 'Transcendent Purpose - The ultimate "why" that gives meaning to all else',
+  L8: 'Business/Social Value - Measurable outcomes and societal impact',
+  L7: 'User Insight - Understanding user behavior, needs, and feedback',
+  L6: 'User Experience - Interface, accessibility, and user journey design',
+  L5: 'System Integration - End-to-end workflows and service coordination',
+  L4: 'API Contracts - Service boundaries and integration points',
+  L3: 'Component Design - Modular architecture and composition',
+  L2: 'Function Logic - Individual units of behavior and computation',
+  L1: 'Code Structure - Syntax, formatting, and basic integrity'
+};
+
+async function buildHierarchy(telosData, options = {}) {
+  console.log(chalk.cyan('\n=== Building Purpose Hierarchy ===\n'));
+  console.log('We\'ll decompose your Telos into 9 levels (L9 → L1).\n');
+
+  const hierarchy = {
+    L9: {
+      level: 'L9',
+      name: 'Telos-Guardian',
+      description: LEVEL_DESCRIPTIONS.L9,
+      purpose: telosData.telos,
+      beneficiaries: telosData.beneficiaries,
+      impact: telosData.impact,
+      constraints: telosData.constraints
+    }
+  };
+
+  if (options.quick) {
+    return buildQuickHierarchy(telosData, hierarchy);
+  }
+
+  hierarchy.L8 = await promptLevel('L8', 'Business/Social Value', 
+    'What measurable business or social outcomes serve your Telos?',
+    `Support: ${telosData.telos}`);
+
+  hierarchy.L7 = await promptLevel('L7', 'User Insight',
+    'What user insights and behaviors must you understand?',
+    `Support: ${hierarchy.L8.purpose}`);
+
+  hierarchy.L6 = await promptLevel('L6', 'User Experience',
+    'What user experience qualities are essential?',
+    `Support: ${hierarchy.L7.purpose}`);
+
+  hierarchy.L5 = await promptLevel('L5', 'System Integration',
+    'What system-level integrations and workflows enable this?',
+    `Support: ${hierarchy.L6.purpose}`);
+
+  hierarchy.L4 = await promptLevel('L4', 'API Contracts',
+    'What API contracts and service boundaries are required?',
+    `Support: ${hierarchy.L5.purpose}`);
+
+  hierarchy.L3 = await promptLevel('L3', 'Component Design',
+    'What component architecture supports these contracts?',
+    `Support: ${hierarchy.L4.purpose}`);
+
+  hierarchy.L2 = await promptLevel('L2', 'Function Logic',
+    'What core functions and logic units are needed?',
+    `Support: ${hierarchy.L3.purpose}`);
+
+  hierarchy.L1 = await promptLevel('L1', 'Code Structure',
+    'What code quality standards ensure reliability?',
+    `Support: ${hierarchy.L2.purpose}`);
+
+  return hierarchy;
+}
+
+async function promptLevel(level, name, question, context) {
+  console.log(chalk.dim(`\n${context}\n`));
+  
+  const { purpose } = await inquirer.prompt([
+    {
+      type: 'input',
+      name: 'purpose',
+      message: `${chalk.bold(level)} - ${name}:\n  ${question}`,
+      validate: (input) => input.trim().length > 0 || 'Purpose cannot be empty'
+    }
+  ]);
+
+  return {
+    level,
+    name,
+    description: LEVEL_DESCRIPTIONS[level],
+    purpose: purpose.trim()
+  };
+}
+
+function buildQuickHierarchy(telosData, baseHierarchy) {
+  const telos = telosData.telos;
+  
+  return {
+    ...baseHierarchy,
+    L8: {
+      level: 'L8',
+      name: 'Market-Analyst',
+      description: LEVEL_DESCRIPTIONS.L8,
+      purpose: `Achieve measurable business outcomes that realize: ${telos}`
+    },
+    L7: {
+      level: 'L7',
+      name: 'Insight-Synthesizer',
+      description: LEVEL_DESCRIPTIONS.L7,
+      purpose: 'Understand user behavior and feedback to inform experience design'
+    },
+    L6: {
+      level: 'L6',
+      name: 'UX-Simulator',
+      description: LEVEL_DESCRIPTIONS.L6,
+      purpose: 'Deliver accessible, intuitive user experiences across all touchpoints'
+    },
+    L5: {
+      level: 'L5',
+      name: 'Journey-Validator',
+      description: LEVEL_DESCRIPTIONS.L5,
+      purpose: 'Ensure end-to-end workflows function cohesively'
+    },
+    L4: {
+      level: 'L4',
+      name: 'Integration-Contractor',
+      description: LEVEL_DESCRIPTIONS.L4,
+      purpose: 'Maintain clear API contracts and service boundaries'
+    },
+    L3: {
+      level: 'L3',
+      name: 'Component-Architect',
+      description: LEVEL_DESCRIPTIONS.L3,
+      purpose: 'Design modular, composable components'
+    },
+    L2: {
+      level: 'L2',
+      name: 'Function-Author',
+      description: LEVEL_DESCRIPTIONS.L2,
+      purpose: 'Write tested, reliable function implementations'
+    },
+    L1: {
+      level: 'L1',
+      name: 'Syntax-Linter',
+      description: LEVEL_DESCRIPTIONS.L1,
+      purpose: 'Ensure code structural integrity and formatting'
+    }
+  };
+}
+
+module.exports = { buildHierarchy };