superclaude-kiro 1.0.0

package/dist/steering/superclaude/sc-troubleshoot.md

@@ -0,0 +1,88 @@
+---
+inclusion: manual
+---
+
+# SuperClaude: troubleshoot
+
+> Converted from Claude Code SuperClaude framework
+> Original: ~/.claude/commands/sc/troubleshoot.md
+
+# /sc:troubleshoot - Issue Diagnosis and Resolution
+
+## Triggers
+- Code defects and runtime error investigation requests
+- Build failure analysis and resolution needs
+- Performance issue diagnosis and optimization requirements
+- Deployment problem analysis and system behavior debugging
+
+## Usage
+```
+/sc:troubleshoot [issue] [--type bug|build|performance|deployment] [--trace] [--fix]
+```
+
+## Behavioral Flow
+1. **Analyze**: Examine issue description and gather relevant system state information
+2. **Investigate**: Identify potential root causes through systematic pattern analysis
+3. **Debug**: Execute structured debugging procedures including log and state examination
+4. **Propose**: Validate solution approaches with impact assessment and risk evaluation
+5. **Resolve**: Apply appropriate fixes and verify resolution effectiveness
+
+Key behaviors:
+- Systematic root cause analysis with hypothesis testing and evidence collection
+- Multi-domain troubleshooting (code, build, performance, deployment)
+- Structured debugging methodologies with comprehensive problem analysis
+- Safe fix application with verification and documentation
+
+## Tool Coordination
+- **Read**: Log analysis and system state examination
+- **Bash**: Diagnostic command execution and system investigation
+- **Grep**: Error pattern detection and log analysis
+- **Write**: Diagnostic reports and resolution documentation
+
+## Key Patterns
+- **Bug Investigation**: Error analysis → stack trace examination → code inspection → fix validation
+- **Build Troubleshooting**: Build log analysis → dependency checking → configuration validation
+- **Performance Diagnosis**: Metrics analysis → bottleneck identification → optimization recommendations
+- **Deployment Issues**: Environment analysis → configuration verification → service validation
+
+## Examples
+
+### Code Bug Investigation
+```
+/sc:troubleshoot "Null pointer exception in user service" --type bug --trace
+# Systematic analysis of error context and stack traces
+# Identifies root cause and provides targeted fix recommendations
+```
+
+### Build Failure Analysis
+```
+/sc:troubleshoot "TypeScript compilation errors" --type build --fix
+# Analyzes build logs and TypeScript configuration
+# Automatically applies safe fixes for common compilation issues
+```
+
+### Performance Issue Diagnosis
+```
+/sc:troubleshoot "API response times degraded" --type performance
+# Performance metrics analysis and bottleneck identification
+# Provides optimization recommendations and monitoring guidance
+```
+
+### Deployment Problem Resolution
+```
+/sc:troubleshoot "Service not starting in production" --type deployment --trace
+# Environment and configuration analysis
+# Systematic verification of deployment requirements and dependencies
+```
+
+## Boundaries
+
+**Will:**
+- Execute systematic issue diagnosis using structured debugging methodologies
+- Provide validated solution approaches with comprehensive problem analysis
+- Apply safe fixes with verification and detailed resolution documentation
+
+**Will Not:**
+- Apply risky fixes without proper analysis and user confirmation
+- Modify production systems without explicit permission and safety validation
+- Make architectural changes without understanding full system impact

package/dist/steering/superclaude/sc-workflow.md

@@ -0,0 +1,97 @@
+---
+inclusion: manual
+---
+
+# SuperClaude: workflow
+
+> Converted from Claude Code SuperClaude framework
+> Original: ~/.claude/commands/sc/workflow.md
+
+# /sc:workflow - Implementation Workflow Generator
+
+## Triggers
+- PRD and feature specification analysis for implementation planning
+- Structured workflow generation for development projects
+- Multi-persona coordination for complex implementation strategies
+- Cross-session workflow management and dependency mapping
+
+## Usage
+```
+/sc:workflow [prd-file|feature-description] [--strategy systematic|agile|enterprise] [--depth shallow|normal|deep] [--parallel]
+```
+
+## Behavioral Flow
+1. **Analyze**: Parse PRD and feature specifications to understand implementation requirements
+2. **Plan**: Generate comprehensive workflow structure with dependency mapping and task orchestration
+3. **Coordinate**: Activate multiple personas for domain expertise and implementation strategy
+4. **Execute**: Create structured step-by-step workflows with automated task coordination
+5. **Validate**: Apply quality gates and ensure workflow completeness across domains
+
+Key behaviors:
+- Multi-persona orchestration across architecture, frontend, backend, security, and devops domains
+- Advanced MCP coordination with intelligent routing for specialized workflow analysis
+- Systematic execution with progressive workflow enhancement and parallel processing
+- Cross-session workflow management with comprehensive dependency tracking
+
+## MCP Integration
+- **Sequential MCP**: Complex multi-step workflow analysis and systematic implementation planning
+- **Context7 MCP**: Framework-specific workflow patterns and implementation best practices
+- **Magic MCP**: UI/UX workflow generation and design system integration strategies
+- **Playwright MCP**: Testing workflow integration and quality assurance automation
+- **Morphllm MCP**: Large-scale workflow transformation and pattern-based optimization
+- **Serena MCP**: Cross-session workflow persistence, memory management, and project context
+
+## Tool Coordination
+- **Read/Write/Edit**: PRD analysis and workflow documentation generation
+- **TodoWrite**: Progress tracking for complex multi-phase workflow execution
+- **Task**: Advanced delegation for parallel workflow generation and multi-agent coordination
+- **WebSearch**: Technology research, framework validation, and implementation strategy analysis
+- **sequentialthinking**: Structured reasoning for complex workflow dependency analysis
+
+## Key Patterns
+- **PRD Analysis**: Document parsing → requirement extraction → implementation strategy development
+- **Workflow Generation**: Task decomposition → dependency mapping → structured implementation planning
+- **Multi-Domain Coordination**: Cross-functional expertise → comprehensive implementation strategies
+- **Quality Integration**: Workflow validation → testing strategies → deployment planning
+
+## Examples
+
+### Systematic PRD Workflow
+```
+/sc:workflow Claudedocs/PRD/feature-spec.md --strategy systematic --depth deep
+# Comprehensive PRD analysis with systematic workflow generation
+# Multi-persona coordination for complete implementation strategy
+```
+
+### Agile Feature Workflow
+```
+/sc:workflow "user authentication system" --strategy agile --parallel
+# Agile workflow generation with parallel task coordination
+# Context7 and Magic MCP for framework and UI workflow patterns
+```
+
+### Enterprise Implementation Planning
+```
+/sc:workflow enterprise-prd.md --strategy enterprise --validate
+# Enterprise-scale workflow with comprehensive validation
+# Security, devops, and architect personas for compliance and scalability
+```
+
+### Cross-Session Workflow Management
+```
+/sc:workflow project-brief.md --depth normal
+# Serena MCP manages cross-session workflow context and persistence
+# Progressive workflow enhancement with memory-driven insights
+```
+
+## Boundaries
+
+**Will:**
+- Generate comprehensive implementation workflows from PRD and feature specifications
+- Coordinate multiple personas and MCP servers for complete implementation strategies
+- Provide cross-session workflow management and progressive enhancement capabilities
+
+**Will Not:**
+- Execute actual implementation tasks beyond workflow planning and strategy
+- Override established development processes without proper analysis and validation
+- Generate workflows without comprehensive requirement analysis and dependency mapping

package/package.json

@@ -0,0 +1,52 @@
+{
+  "name": "superclaude-kiro",
+  "version": "1.0.0",
+  "description": "SuperClaude Framework for Kiro CLI - Easy installation for teams",
+  "type": "module",
+  "bin": {
+    "superclaude-kiro": "./bin/superclaude-kiro.js"
+  },
+  "main": "src/cli.js",
+  "scripts": {
+    "build": "node scripts/build.js",
+    "sync:claude": "node scripts/sync-from-claude.js",
+    "sync:github": "node scripts/sync-from-github.js",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [
+    "superclaude",
+    "kiro",
+    "claude",
+    "ai",
+    "cli",
+    "development",
+    "productivity"
+  ],
+  "author": "Richardmbs12 <richardmbs3@gmail.com>",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/The-SBG-A-Team/super-claude-for-kiro.git"
+  },
+  "homepage": "https://github.com/The-SBG-A-Team/super-claude-for-kiro#readme",
+  "bugs": {
+    "url": "https://github.com/The-SBG-A-Team/super-claude-for-kiro/issues"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "dependencies": {
+    "commander": "^12.1.0",
+    "chalk": "^5.3.0",
+    "fs-extra": "^11.2.0",
+    "ora": "^8.1.0"
+  },
+  "files": [
+    "bin/",
+    "src/",
+    "dist/",
+    "templates/",
+    "README.md",
+    "LICENSE"
+  ]
+}

package/src/cli.js

@@ -0,0 +1,23 @@
+import { installSuperClaude, updateSuperClaude, uninstallSuperClaude, getStatus } from './installer.js';
+
+export async function install(options) {
+  await installSuperClaude({
+    force: options.force || false,
+    mcp: options.mcp !== false,
+    default: options.default !== false
+  });
+}
+
+export async function update(options) {
+  await updateSuperClaude();
+}
+
+export async function uninstall(options) {
+  await uninstallSuperClaude({
+    skipConfirm: options.yes || false
+  });
+}
+
+export async function status(options) {
+  await getStatus();
+}

package/src/converter.js

@@ -0,0 +1,63 @@
+import fs from 'fs-extra';
+import path from 'path';
+
+/**
+ * Convert a Claude Code command file to Kiro steering file format
+ * @param {string} src - Source file path
+ * @param {string} dst - Destination file path
+ */
+export async function convertCommand(src, dst) {
+  const content = await fs.readFile(src, 'utf-8');
+  const filename = path.basename(src, '.md');
+
+  const kiroContent = `---
+inclusion: manual
+---
+
+# SuperClaude: ${filename}
+
+> Converted from Claude Code SuperClaude framework
+> Original: ~/.claude/commands/sc/${path.basename(src)}
+
+${stripFrontmatter(content)}`;
+
+  await fs.writeFile(dst, kiroContent);
+}
+
+/**
+ * Strip YAML frontmatter from markdown content
+ * @param {string} content - Markdown content with potential frontmatter
+ * @returns {string} Content without frontmatter
+ */
+export function stripFrontmatter(content) {
+  // Match YAML frontmatter at the start of the file
+  const match = content.match(/^---\r?\n[\s\S]*?\r?\n---\r?\n([\s\S]*)$/);
+  return match ? match[1].trim() : content.trim();
+}
+
+/**
+ * Parse YAML frontmatter from markdown content
+ * @param {string} content - Markdown content with frontmatter
+ * @returns {Object} Parsed frontmatter object
+ */
+export function parseFrontmatter(content) {
+  const match = content.match(/^---\r?\n([\s\S]*?)\r?\n---/);
+  if (!match) return {};
+
+  const yaml = match[1];
+  const result = {};
+
+  // Simple YAML parsing for key: value pairs
+  const lines = yaml.split('\n');
+  for (const line of lines) {
+    const colonIndex = line.indexOf(':');
+    if (colonIndex > 0) {
+      const key = line.slice(0, colonIndex).trim();
+      const value = line.slice(colonIndex + 1).trim();
+      // Remove quotes if present
+      result[key] = value.replace(/^["']|["']$/g, '');
+    }
+  }
+
+  return result;
+}

package/src/installer.js

@@ -0,0 +1,319 @@
+import fs from 'fs-extra';
+import path from 'path';
+import os from 'os';
+import chalk from 'chalk';
+import ora from 'ora';
+import { fileURLToPath } from 'url';
+import { createRequire } from 'module';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+const require = createRequire(import.meta.url);
+
+const KIRO_DIR = path.join(os.homedir(), '.kiro');
+const DIST_DIR = path.join(__dirname, '..', 'dist');
+
+export async function installSuperClaude(options = {}) {
+  const spinner = ora('Installing SuperClaude for Kiro...').start();
+
+  try {
+    // 1. Verify Kiro CLI directory exists
+    if (!await fs.pathExists(KIRO_DIR)) {
+      spinner.fail(chalk.red('Kiro CLI not found.'));
+      console.log(chalk.yellow('\nPlease install Kiro CLI first:'));
+      console.log(chalk.cyan('  npm install -g @anthropic-ai/kiro-cli'));
+      console.log(chalk.yellow('  or visit: https://kiro.dev/docs/cli/'));
+      process.exit(1);
+    }
+
+    // 2. Check for existing installation
+    const steeringDir = path.join(KIRO_DIR, 'steering', 'superclaude');
+    if (await fs.pathExists(steeringDir) && !options.force) {
+      spinner.fail(chalk.red('SuperClaude already installed.'));
+      console.log(chalk.yellow('\nTo overwrite, run:'));
+      console.log(chalk.cyan('  npx superclaude-kiro install --force'));
+      process.exit(1);
+    }
+
+    // 3. Verify dist directory exists
+    if (!await fs.pathExists(DIST_DIR)) {
+      spinner.fail(chalk.red('Distribution files not found.'));
+      console.log(chalk.yellow('\nPackage may be corrupted. Try reinstalling:'));
+      console.log(chalk.cyan('  npm cache clean --force'));
+      console.log(chalk.cyan('  npx superclaude-kiro@latest install'));
+      process.exit(1);
+    }
+
+    // 4. Create directories
+    spinner.text = 'Creating directories...';
+    await fs.ensureDir(path.join(KIRO_DIR, 'steering', 'superclaude'));
+    await fs.ensureDir(path.join(KIRO_DIR, 'agents'));
+    await fs.ensureDir(path.join(KIRO_DIR, 'settings'));
+    await fs.ensureDir(path.join(KIRO_DIR, 'docs'));
+
+    // 5. Copy steering files
+    spinner.text = 'Installing steering files...';
+    const steeringSrc = path.join(DIST_DIR, 'steering', 'superclaude');
+    if (await fs.pathExists(steeringSrc)) {
+      await fs.copy(steeringSrc, path.join(KIRO_DIR, 'steering', 'superclaude'));
+    }
+
+    // 6. Copy agents
+    spinner.text = 'Installing agents...';
+    const agentsSrc = path.join(DIST_DIR, 'agents');
+    if (await fs.pathExists(agentsSrc)) {
+      const agents = await fs.readdir(agentsSrc);
+      for (const agent of agents) {
+        if (agent.endsWith('.json')) {
+          await fs.copy(
+            path.join(agentsSrc, agent),
+            path.join(KIRO_DIR, 'agents', agent)
+          );
+        }
+      }
+    }
+
+    // 7. Configure MCP servers (optional)
+    if (options.mcp !== false) {
+      spinner.text = 'Configuring MCP servers...';
+      await configureMcpServers();
+    }
+
+    // 8. Set default agent (optional)
+    if (options.default !== false) {
+      spinner.text = 'Setting default agent...';
+      await setDefaultAgent();
+    }
+
+    // 9. Create version file
+    spinner.text = 'Finalizing installation...';
+    const pkg = require('../package.json');
+    await fs.writeJson(
+      path.join(KIRO_DIR, 'docs', 'superclaude-version.json'),
+      {
+        version: pkg.version,
+        installedAt: new Date().toISOString(),
+        source: 'npm:superclaude-kiro'
+      },
+      { spaces: 2 }
+    );
+
+    // Count installed files
+    const steeringFiles = await countFiles(path.join(KIRO_DIR, 'steering', 'superclaude'), '.md');
+    const agentFiles = await countFiles(path.join(KIRO_DIR, 'agents'), '.json', 'sc-');
+
+    spinner.succeed(chalk.green('SuperClaude installed successfully!'));
+
+    console.log('');
+    console.log(chalk.gray('  Installed:'));
+    console.log(chalk.gray(`    - ${steeringFiles} steering files`));
+    console.log(chalk.gray(`    - ${agentFiles + 1} agents`));
+    console.log('');
+    console.log(chalk.cyan('Quick Start:'));
+    console.log('  1. Run: ' + chalk.yellow('kiro-cli chat'));
+    console.log('  2. Try: ' + chalk.yellow('#sc-help'));
+    console.log('');
+
+  } catch (error) {
+    spinner.fail(chalk.red('Installation failed: ' + error.message));
+    process.exit(1);
+  }
+}
+
+export async function updateSuperClaude() {
+  const spinner = ora('Checking for updates...').start();
+
+  try {
+    // Check if installed
+    const versionFile = path.join(KIRO_DIR, 'docs', 'superclaude-version.json');
+    if (!await fs.pathExists(versionFile)) {
+      spinner.fail(chalk.red('SuperClaude is not installed.'));
+      console.log(chalk.yellow('\nTo install, run:'));
+      console.log(chalk.cyan('  npx superclaude-kiro install'));
+      process.exit(1);
+    }
+
+    spinner.text = 'Updating SuperClaude...';
+
+    // Perform fresh install with force
+    await installSuperClaude({ force: true, mcp: true, default: true });
+
+  } catch (error) {
+    spinner.fail(chalk.red('Update failed: ' + error.message));
+    process.exit(1);
+  }
+}
+
+export async function uninstallSuperClaude(options = {}) {
+  const spinner = ora('Uninstalling SuperClaude...').start();
+
+  try {
+    // Check if installed
+    const steeringDir = path.join(KIRO_DIR, 'steering', 'superclaude');
+    if (!await fs.pathExists(steeringDir)) {
+      spinner.fail(chalk.red('SuperClaude is not installed.'));
+      process.exit(1);
+    }
+
+    // Remove steering files
+    spinner.text = 'Removing steering files...';
+    await fs.remove(steeringDir);
+
+    // Remove agents
+    spinner.text = 'Removing agents...';
+    const agents = ['superclaude.json', 'sc-pm.json', 'sc-implement.json', 'sc-analyze.json'];
+    for (const agent of agents) {
+      const agentPath = path.join(KIRO_DIR, 'agents', agent);
+      if (await fs.pathExists(agentPath)) {
+        await fs.remove(agentPath);
+      }
+    }
+
+    // Remove version file
+    spinner.text = 'Cleaning up...';
+    await fs.remove(path.join(KIRO_DIR, 'docs', 'superclaude-version.json'));
+
+    // Reset default agent if it was superclaude
+    const cliSettingsPath = path.join(KIRO_DIR, 'settings', 'cli.json');
+    if (await fs.pathExists(cliSettingsPath)) {
+      const settings = await fs.readJson(cliSettingsPath);
+      if (settings['chat.defaultAgent'] === 'superclaude') {
+        delete settings['chat.defaultAgent'];
+        await fs.writeJson(cliSettingsPath, settings, { spaces: 2 });
+      }
+    }
+
+    spinner.succeed(chalk.green('SuperClaude uninstalled successfully!'));
+    console.log('');
+    console.log(chalk.gray('  Note: MCP server configurations were preserved.'));
+    console.log('');
+
+  } catch (error) {
+    spinner.fail(chalk.red('Uninstall failed: ' + error.message));
+    process.exit(1);
+  }
+}
+
+export async function getStatus() {
+  console.log('');
+  console.log(chalk.bold('  SuperClaude for Kiro'));
+  console.log(chalk.gray('  ' + '─'.repeat(30)));
+
+  // Check Kiro CLI
+  if (!await fs.pathExists(KIRO_DIR)) {
+    console.log(chalk.red('  Status:      Not installed (Kiro CLI missing)'));
+    console.log('');
+    return;
+  }
+
+  // Check installation
+  const versionFile = path.join(KIRO_DIR, 'docs', 'superclaude-version.json');
+  const steeringDir = path.join(KIRO_DIR, 'steering', 'superclaude');
+
+  if (!await fs.pathExists(versionFile) || !await fs.pathExists(steeringDir)) {
+    console.log(chalk.yellow('  Status:      Not installed'));
+    console.log('');
+    console.log(chalk.gray('  To install:'));
+    console.log(chalk.cyan('    npx superclaude-kiro install'));
+    console.log('');
+    return;
+  }
+
+  // Read version info
+  const versionInfo = await fs.readJson(versionFile);
+  const installedDate = new Date(versionInfo.installedAt).toLocaleDateString();
+
+  console.log(chalk.green('  Status:      Installed'));
+  console.log(chalk.white(`  Version:     ${versionInfo.version}`));
+  console.log(chalk.gray(`  Installed:   ${installedDate}`));
+  console.log('');
+
+  // Count components
+  const steeringFiles = await countFiles(steeringDir, '.md');
+  const agentFiles = await countFiles(path.join(KIRO_DIR, 'agents'), '.json', 'sc-');
+
+  console.log(chalk.gray('  Components:'));
+  console.log(chalk.green(`    ✔ Steering files (${steeringFiles})`));
+  console.log(chalk.green(`    ✔ Agents (${agentFiles + 1})`));
+
+  // Check MCP
+  const mcpPath = path.join(KIRO_DIR, 'settings', 'mcp.json');
+  if (await fs.pathExists(mcpPath)) {
+    const mcpConfig = await fs.readJson(mcpPath);
+    const mcpCount = Object.keys(mcpConfig.mcpServers || {}).length;
+    console.log(chalk.green(`    ✔ MCP servers (${mcpCount})`));
+  } else {
+    console.log(chalk.yellow('    ○ MCP servers (not configured)'));
+  }
+
+  // Check default agent
+  const cliSettingsPath = path.join(KIRO_DIR, 'settings', 'cli.json');
+  if (await fs.pathExists(cliSettingsPath)) {
+    const settings = await fs.readJson(cliSettingsPath);
+    if (settings['chat.defaultAgent'] === 'superclaude') {
+      console.log(chalk.green('    ✔ Default agent: superclaude'));
+    } else {
+      console.log(chalk.yellow(`    ○ Default agent: ${settings['chat.defaultAgent'] || 'none'}`));
+    }
+  }
+
+  console.log('');
+}
+
+// Helper functions
+
+async function configureMcpServers() {
+  const mcpPath = path.join(KIRO_DIR, 'settings', 'mcp.json');
+  const templatePath = path.join(DIST_DIR, 'mcp', 'mcp-servers.json');
+
+  let existingConfig = { mcpServers: {} };
+  if (await fs.pathExists(mcpPath)) {
+    existingConfig = await fs.readJson(mcpPath);
+  }
+
+  let newServers = { mcpServers: {} };
+  if (await fs.pathExists(templatePath)) {
+    newServers = await fs.readJson(templatePath);
+  }
+
+  // Merge MCP servers (existing takes precedence to preserve user customizations)
+  const mergedConfig = {
+    mcpServers: {
+      ...newServers.mcpServers,
+      ...existingConfig.mcpServers
+    }
+  };
+
+  await fs.ensureDir(path.join(KIRO_DIR, 'settings'));
+  await fs.writeJson(mcpPath, mergedConfig, { spaces: 2 });
+}
+
+async function setDefaultAgent() {
+  const cliSettingsPath = path.join(KIRO_DIR, 'settings', 'cli.json');
+
+  let settings = {};
+  if (await fs.pathExists(cliSettingsPath)) {
+    settings = await fs.readJson(cliSettingsPath);
+  }
+
+  settings['chat.defaultAgent'] = 'superclaude';
+  settings['chat.model'] = settings['chat.model'] || 'claude-sonnet-4.5';
+  settings['chat.enableThinking'] = settings['chat.enableThinking'] !== false;
+  settings['chat.enableTodoList'] = settings['chat.enableTodoList'] !== false;
+  settings['chat.enableDelegate'] = settings['chat.enableDelegate'] !== false;
+
+  await fs.ensureDir(path.join(KIRO_DIR, 'settings'));
+  await fs.writeJson(cliSettingsPath, settings, { spaces: 2 });
+}
+
+async function countFiles(dir, extension, prefix = '') {
+  if (!await fs.pathExists(dir)) return 0;
+
+  const files = await fs.readdir(dir);
+  return files.filter(f => {
+    const matchesExt = f.endsWith(extension);
+    const matchesPrefix = prefix ? f.startsWith(prefix) : true;
+    return matchesExt && matchesPrefix;
+  }).length;
+}