telos-framework 0.1.4 → 0.3.0

package/.claude/settings.json

@@ -0,0 +1,125 @@
+{
+  "deniedTools": [
+    "mcp__task-master__initialize_project"
+  ],
+  "hooks": {
+    "SessionStart": [
+      {
+        "matcher": "startup",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "$CLAUDE_PROJECT_DIR/.claude/hooks/load-behavioral-system.sh"
+          }
+        ]
+      },
+      {
+        "matcher": "resume",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "$CLAUDE_PROJECT_DIR/.claude/hooks/load-behavioral-system.sh"
+          }
+        ]
+      },
+      {
+        "matcher": "clear",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "$CLAUDE_PROJECT_DIR/.claude/hooks/load-behavioral-system.sh"
+          }
+        ]
+      }
+    ],
+    "PreToolUse": [
+      {
+        "matcher": "Bash",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "$CLAUDE_PROJECT_DIR/.claude/hooks/block-destructive-commands.sh"
+          }
+        ]
+      },
+      {
+        "matcher": "Write|Edit|MultiEdit",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "$CLAUDE_PROJECT_DIR/.claude/hooks/directive-enforcer.sh"
+          },
+          {
+            "type": "command",
+            "command": "$CLAUDE_PROJECT_DIR/.claude/hooks/collective-metrics.sh"
+          }
+        ]
+      },
+      {
+        "matcher": ".*",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "$CLAUDE_PROJECT_DIR/.claude/hooks/collective-metrics.sh"
+          }
+        ]
+      }
+    ],
+    "PostToolUse": [
+      {
+        "matcher": "Task",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "$CLAUDE_PROJECT_DIR/.claude/hooks/test-driven-handoff.sh"
+          },
+          {
+            "type": "command",
+            "command": "$CLAUDE_PROJECT_DIR/.claude/hooks/collective-metrics.sh"
+          }
+        ]
+      },
+      {
+        "matcher": "Write|Edit|MultiEdit",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "$CLAUDE_PROJECT_DIR/.claude/hooks/collective-metrics.sh"
+          }
+        ]
+      }
+    ],
+    "SubagentStop": [
+      {
+        "matcher": "mock-.*",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "$CLAUDE_PROJECT_DIR/.claude/hooks/mock-deliverable-generator.sh"
+          },
+          {
+            "type": "command",
+            "command": "$CLAUDE_PROJECT_DIR/.claude/hooks/test-driven-handoff.sh"
+          },
+          {
+            "type": "command",
+            "command": "$CLAUDE_PROJECT_DIR/.claude/hooks/collective-metrics.sh"
+          }
+        ]
+      },
+      {
+        "matcher": ".*",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "$CLAUDE_PROJECT_DIR/.claude/hooks/test-driven-handoff.sh"
+          },
+          {
+            "type": "command",
+            "command": "$CLAUDE_PROJECT_DIR/.claude/hooks/collective-metrics.sh"
+          }
+        ]
+      }
+    ]
+  }
+}

package/README.md

@@ -66,22 +66,35 @@ telos init
 
 ## Quick Start
 
-### 1. Initialize Your Project
+### 1. Install Telos Commands
 
 ```bash
 cd your-project
 telos init
 ```
 
-The interactive initialization will:
+This installs Telos slash commands to `.claude/commands/telos/` and sets up
+`AGENTS.md` and `CLAUDE.md` templates.
 
-- Capture your project's ultimate purpose (Telos)
-- Decompose it into a 9-level hierarchy
-- Discover available tools and MCP servers
-- Generate adapted agent definitions
-- Create platform-specific configurations
+### 2. Initialize with AI
 
-### 2. Start Development
+Open your project in Claude Code (or your AI coding assistant) and run:
+
+```
+/telos-init
+```
+
+The AI will:
+
+- Analyze your codebase (README, package files, source structure)
+- Propose a complete 9-level purpose hierarchy
+- Auto-generate technical layers (L1-L4) from detected tools
+- Ask you to review strategic layers (L9-L5)
+- Generate all agent definitions and configuration files
+
+**Time: ~2 minutes** (vs. 10 minutes with CLI prompts)
+
+### 3. Start Development
 
 Your AI assistants now operate as a coherent multi-agent collective:
 
@@ -101,10 +114,10 @@ L1 Syntax-Linter: Ensures code quality
 (Bottom-up validation confirms alignment)
 ```
 
-### 3. Validate Alignment
+### 4. Validate Alignment
 
-```bash
-telos validate
+```
+/telos-validate
 ```
 
 Check that all work traces back to your ultimate Telos.
@@ -155,14 +168,25 @@ Full integration with [OpenSpec](https://openspec.dev) workflow:
 
 ## Commands
 
+### CLI Commands
+
 ```bash
-telos init              # Initialize Telos in your project
-telos status            # Show current configuration
-telos rediscover        # Update tool detection
-telos validate          # Check Telos alignment
+telos init              # Install Telos slash commands and memory files
 telos --help            # Show all commands
 ```
 
+### Slash Commands (AI-Native)
+
+Use these in Claude Code, OpenCode, or Cursor:
+
+```
+/telos-init             # Initialize Telos with AI-driven analysis
+/telos-quick            # Fast initialization (auto-accept AI proposals)
+/telos-validate         # Check code alignment with purpose hierarchy
+/telos-status           # Show current Telos configuration
+/telos-reset            # Clear and reinitialize
+```
+
 ## Project Structure
 
 After initialization:

package/lib/commands/init-state.js

@@ -0,0 +1,102 @@
+const fs = require('fs');
+const path = require('path');
+
+const STATE_FILE = '.telos-init-state.json';
+
+/**
+ * Get the state file path for the current directory
+ */
+function getStateFilePath(cwd = process.cwd()) {
+  return path.join(cwd, STATE_FILE);
+}
+
+/**
+ * Load existing initialization state if present
+ */
+function loadState(cwd = process.cwd()) {
+  const statePath = getStateFilePath(cwd);
+  
+  if (!fs.existsSync(statePath)) {
+    return null;
+  }
+  
+  try {
+    const content = fs.readFileSync(statePath, 'utf8');
+    return JSON.parse(content);
+  } catch (error) {
+    return null;
+  }
+}
+
+/**
+ * Save initialization state
+ */
+function saveState(state, cwd = process.cwd()) {
+  const statePath = getStateFilePath(cwd);
+  
+  try {
+    fs.writeFileSync(statePath, JSON.stringify(state, null, 2), 'utf8');
+    return true;
+  } catch (error) {
+    return false;
+  }
+}
+
+/**
+ * Update specific phase data in state
+ */
+function updatePhase(phase, data, cwd = process.cwd()) {
+  const currentState = loadState(cwd) || { phases: {}, timestamp: new Date().toISOString() };
+  
+  currentState.phases[phase] = {
+    ...data,
+    completedAt: new Date().toISOString()
+  };
+  currentState.lastPhase = phase;
+  currentState.lastUpdated = new Date().toISOString();
+  
+  return saveState(currentState, cwd);
+}
+
+/**
+ * Clear initialization state (call on successful completion)
+ */
+function clearState(cwd = process.cwd()) {
+  const statePath = getStateFilePath(cwd);
+  
+  try {
+    if (fs.existsSync(statePath)) {
+      fs.unlinkSync(statePath);
+    }
+    return true;
+  } catch (error) {
+    return false;
+  }
+}
+
+/**
+ * Check if a specific phase is completed
+ */
+function isPhaseComplete(state, phase) {
+  return !!(state && state.phases && state.phases[phase]);
+}
+
+/**
+ * Get phase data if it exists
+ */
+function getPhaseData(state, phase) {
+  if (state && state.phases && state.phases[phase]) {
+    return state.phases[phase].data;
+  }
+  return null;
+}
+
+module.exports = {
+  loadState,
+  saveState,
+  updatePhase,
+  clearState,
+  isPhaseComplete,
+  getPhaseData,
+  getStateFilePath
+};

package/lib/commands/init.js

@@ -1,117 +1,80 @@
 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');
+const { installSlashCommands } = require('../installers/slash-commands');
+const { setupMemoryFiles } = require('../installers/memory-files');
 
 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'));
+  console.log(chalk.bold.cyan('\n╔══════════════════════════════════════════╗'));
+  console.log(chalk.bold.cyan('║   Telos Framework Installation       ║'));
+  console.log(chalk.bold.cyan('╚══════════════════════════════════════════╝\n'));
 
   try {
-    const telosData = await discoverTelos(options);
-    
-    let hierarchy;
-    
-    if (options.quick) {
-      const spinner = ora('Building purpose hierarchy...').start();
-      hierarchy = await buildHierarchy(telosData, options);
-      spinner.succeed('Purpose hierarchy built');
-    } else {
-      hierarchy = await buildHierarchy(telosData, options);
-      console.log(chalk.green('\n✓ Purpose hierarchy built\n'));
-    }
-
-    const spinner = ora('Generating TELOS.md...').start();
-    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}`);
+    const projectRoot = process.cwd();
 
-    console.log(chalk.green('\n✓ Phase 2: Tool Discovery Complete\n'));
+    console.log(chalk.cyan('Installing Telos slash commands...\n'));
 
-    spinner.start('Generating all agent definitions...');
-    const agentsDir = path.join(process.cwd(), 'telos', 'agents');
+    const commandResults = await installSlashCommands(projectRoot);
     
-    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'));
+    for (const { platform, results } of commandResults) {
+      const successful = results.filter(r => r.success);
+      if (successful.length > 0) {
+        console.log(chalk.green(`✓ Installed ${successful.length} command(s) for ${platform}:`));
+        successful.forEach(r => {
+          console.log(chalk.dim(`  - /telos-${r.file.replace('.md', '')}`));
+        });
+      }
+      
+      const failed = results.filter(r => !r.success);
+      if (failed.length > 0) {
+        console.log(chalk.yellow(`⚠ Failed to install ${failed.length} command(s):`));
+        failed.forEach(r => {
+          console.log(chalk.dim(`  - ${r.file}: ${r.error}`));
+        });
+      }
+    }
 
-    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}`);
+    console.log(chalk.cyan('\nSetting up memory files...\n'));
 
-    spinner.start('Detecting platforms and creating symlinks...');
-    const platforms = await detectPlatforms(process.cwd());
-    let symlinkCount = 0;
+    const memoryResults = await setupMemoryFiles(projectRoot);
     
-    for (const platform of platforms) {
-      const config = getPlatformConfig(platform.name);
-      const results = await createSymlinks(process.cwd(), config);
-      symlinkCount += results.filter(r => r.success).length;
+    if (memoryResults.agents.created) {
+      console.log(chalk.green('✓ Created AGENTS.md'));
+    } else if (memoryResults.agents.updated) {
+      console.log(chalk.green('✓ Updated AGENTS.md with Telos content'));
+    } else {
+      console.log(chalk.dim('✓ AGENTS.md already contains Telos content'));
     }
     
-    spinner.succeed(`Created ${symlinkCount} platform symlink(s) for ${platforms.map(p => p.name).join(', ')}`);
+    if (memoryResults.claude.created) {
+      console.log(chalk.green('✓ Created CLAUDE.md'));
+    } else if (memoryResults.claude.updated) {
+      console.log(chalk.green('✓ Updated CLAUDE.md with Telos instructions'));
+    } else {
+      console.log(chalk.dim('✓ CLAUDE.md already contains Telos content'));
+    }
 
-    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`));
+    console.log(chalk.bold.cyan('\n╔══════════════════════════════════════════╗'));
+    console.log(chalk.bold.cyan('║       Installation Complete!         ║'));
+    console.log(chalk.bold.cyan('╚══════════════════════════════════════════╝\n'));
+
+    console.log(chalk.bold.white('Next steps:\n'));
+    console.log(chalk.white('1. Open this project in Claude Code (or your AI coding assistant)'));
+    console.log(chalk.white('2. Run the slash command: ') + chalk.bold.green('/telos-init'));
+    console.log(chalk.white('3. Follow the interactive setup to configure your purpose hierarchy\n'));
+
+    console.log(chalk.dim('Available commands after initialization:'));
+    console.log(chalk.dim('  /telos-init     - Initialize Telos with interactive review'));
+    console.log(chalk.dim('  /telos-quick    - Quick initialization (auto-accept AI proposals)'));
+    console.log(chalk.dim('  /telos-validate - Check code alignment with purpose'));
+    console.log(chalk.dim('  /telos-status   - Show current Telos configuration'));
+    console.log(chalk.dim('  /telos-reset    - Clear and reinitialize\n'));
 
   } catch (error) {
-    console.error(chalk.red('\n✗ Initialization failed:'), error.message);
+    console.error(chalk.red('\n✗ Installation failed:'), error.message);
     if (options.verbose) {
-      console.error(error);
+      console.error(error.stack);
     }
+    console.log(chalk.yellow('\nPlease check the error and try again.\n'));
     process.exit(1);
   }
 }

package/lib/installers/memory-files.js

@@ -0,0 +1,77 @@
+const fs = require('fs').promises;
+const path = require('path');
+
+async function fileExists(filePath) {
+  try {
+    await fs.access(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+async function readTemplate(templateName) {
+  const templatePath = path.join(__dirname, '../../templates', templateName);
+  return await fs.readFile(templatePath, 'utf-8');
+}
+
+async function createAgentsMd(projectRoot) {
+  const agentsMdPath = path.join(projectRoot, 'AGENTS.md');
+  
+  if (await fileExists(agentsMdPath)) {
+    const existingContent = await fs.readFile(agentsMdPath, 'utf-8');
+    
+    if (existingContent.includes('Telos Framework')) {
+      return { created: false, updated: false, path: agentsMdPath, reason: 'already-exists' };
+    }
+    
+    const template = await readTemplate('AGENTS.md');
+    const updatedContent = existingContent + '\n\n' + template;
+    await fs.writeFile(agentsMdPath, updatedContent);
+    
+    return { created: false, updated: true, path: agentsMdPath };
+  }
+  
+  const template = await readTemplate('AGENTS.md');
+  await fs.writeFile(agentsMdPath, template);
+  
+  return { created: true, updated: false, path: agentsMdPath };
+}
+
+async function createClaudeMd(projectRoot) {
+  const claudeMdPath = path.join(projectRoot, 'CLAUDE.md');
+  
+  if (await fileExists(claudeMdPath)) {
+    const existingContent = await fs.readFile(claudeMdPath, 'utf-8');
+    
+    if (existingContent.includes('Telos Framework')) {
+      return { created: false, updated: false, path: claudeMdPath, reason: 'already-exists' };
+    }
+    
+    const template = await readTemplate('CLAUDE.md');
+    const updatedContent = existingContent + '\n\n' + template;
+    await fs.writeFile(claudeMdPath, updatedContent);
+    
+    return { created: false, updated: true, path: claudeMdPath };
+  }
+  
+  const template = await readTemplate('CLAUDE.md');
+  await fs.writeFile(claudeMdPath, template);
+  
+  return { created: true, updated: false, path: claudeMdPath };
+}
+
+async function setupMemoryFiles(projectRoot) {
+  const results = {
+    agents: await createAgentsMd(projectRoot),
+    claude: await createClaudeMd(projectRoot)
+  };
+  
+  return results;
+}
+
+module.exports = {
+  createAgentsMd,
+  createClaudeMd,
+  setupMemoryFiles
+};

package/lib/installers/slash-commands.js

@@ -0,0 +1,77 @@
+const fs = require('fs').promises;
+const path = require('path');
+const chalk = require('chalk');
+
+async function detectPlatform(projectRoot) {
+  const claudeDir = path.join(projectRoot, '.claude');
+  const opencodeDir = path.join(projectRoot, '.opencode');
+  
+  const hasClaudeDir = await fs.access(claudeDir).then(() => true).catch(() => false);
+  const hasOpencodeDir = await fs.access(opencodeDir).then(() => true).catch(() => false);
+  
+  const platforms = [];
+  if (hasClaudeDir) platforms.push('claude');
+  if (hasOpencodeDir) platforms.push('opencode');
+  
+  if (platforms.length === 0) {
+    platforms.push('claude');
+  }
+  
+  return platforms;
+}
+
+async function ensureDirectories(projectRoot, platform) {
+  const commandsDir = platform === 'claude' 
+    ? path.join(projectRoot, '.claude', 'commands', 'telos')
+    : path.join(projectRoot, '.opencode', 'command', 'telos');
+  
+  await fs.mkdir(commandsDir, { recursive: true });
+  return commandsDir;
+}
+
+async function copyCommandFiles(projectRoot, platform) {
+  const sourceDir = path.join(__dirname, '../../.claude/commands/telos');
+  const targetDir = await ensureDirectories(projectRoot, platform);
+  
+  const commandFiles = [
+    'init.md',
+    'quick.md',
+    'reset.md',
+    'validate.md',
+    'status.md'
+  ];
+  
+  const results = [];
+  for (const file of commandFiles) {
+    const sourcePath = path.join(sourceDir, file);
+    const targetPath = path.join(targetDir, file);
+    
+    try {
+      await fs.copyFile(sourcePath, targetPath);
+      results.push({ file, success: true, path: targetPath });
+    } catch (error) {
+      results.push({ file, success: false, error: error.message });
+    }
+  }
+  
+  return results;
+}
+
+async function installSlashCommands(projectRoot) {
+  const platforms = await detectPlatform(projectRoot);
+  
+  const allResults = [];
+  for (const platform of platforms) {
+    const results = await copyCommandFiles(projectRoot, platform);
+    allResults.push({ platform, results });
+  }
+  
+  return allResults;
+}
+
+module.exports = {
+  detectPlatform,
+  ensureDirectories,
+  copyCommandFiles,
+  installSlashCommands
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "telos-framework",
-  "version": "0.1.4",
+  "version": "0.3.0",
   "description": "Telos-driven Multi-Agent Development Framework - A philosophically-grounded AI collective for purpose-aligned software development",
   "main": "index.js",
   "bin": {
@@ -24,7 +24,10 @@
     "claude",
     "cursor",
     "copilot",
-    "orchestrator"
+    "orchestrator",
+    "claude-code-plugin",
+    "slash-commands",
+    "ai-native"
   ],
   "author": "Alan Colver",
   "license": "MIT",
@@ -40,6 +43,8 @@
     "bin/",
     "lib/",
     "logos/",
+    ".claude/",
+    "templates/",
     "LICENSE",
     "README.md",
     "USAGE.md"