scene-capability-engine 3.3.5 → 3.3.10

package/lib/steering/steering-manager.js

@@ -9,8 +9,8 @@ const inquirer = require('inquirer');
  */
 class SteeringManager {
   constructor() {
-    this.steeringDir = '.kiro/steering';
-    this.backupBaseDir = '.kiro/backups';
+    this.steeringDir = '.sce/steering';
+    this.backupBaseDir = '.sce/backups';
   }
 
   /**
@@ -83,7 +83,7 @@ class SteeringManager {
     });
     
     console.log('');
-    console.log('AI IDE loads all files in .kiro/steering/, which means you must');
+    console.log('AI IDE loads all files in .sce/steering/, which means you must');
     console.log('choose between sce steering rules OR your project\'s existing rules.');
     console.log('');
 
@@ -169,7 +169,7 @@ class SteeringManager {
    */
   async installKseSteering(projectPath) {
     const steeringPath = path.join(projectPath, this.steeringDir);
-    const templatePath = path.join(__dirname, '../../template/.kiro/steering');
+    const templatePath = path.join(__dirname, '../../template/.sce/steering');
 
     try {
       // 确保 steering 目录存在

package/lib/task/task-claimer.js

@@ -202,7 +202,7 @@ class TaskClaimer {
    * @returns {Promise<Object>} 认领结果
    */
   async claimTask(projectPath, specName, taskId, username, force = false) {
-    const tasksPath = path.join(projectPath, '.kiro/specs', specName, 'tasks.md');
+    const tasksPath = path.join(projectPath, '.sce/specs', specName, 'tasks.md');
 
     try {
       // 检查文件是否存在
@@ -284,7 +284,7 @@ class TaskClaimer {
    * @returns {Promise<Object>} 释放结果
    */
   async unclaimTask(projectPath, specName, taskId, username) {
-    const tasksPath = path.join(projectPath, '.kiro/specs', specName, 'tasks.md');
+    const tasksPath = path.join(projectPath, '.sce/specs', specName, 'tasks.md');
 
     try {
       // 检查文件是否存在
@@ -360,7 +360,7 @@ class TaskClaimer {
    * @returns {Promise<Array>} 已认领的任务列表
    */
   async getClaimedTasks(projectPath, specName) {
-    const tasksPath = path.join(projectPath, '.kiro/specs', specName, 'tasks.md');
+    const tasksPath = path.join(projectPath, '.sce/specs', specName, 'tasks.md');
 
     try {
       const exists = await fs.pathExists(tasksPath);
@@ -397,7 +397,7 @@ class TaskClaimer {
    * @returns {Promise<Object>} 更新结果
    */
   async updateTaskStatus(projectPath, specName, taskId, status) {
-    const tasksPath = path.join(projectPath, '.kiro/specs', specName, 'tasks.md');
+    const tasksPath = path.join(projectPath, '.sce/specs', specName, 'tasks.md');
 
     try {
       const exists = await fs.pathExists(tasksPath);
@@ -461,7 +461,7 @@ class TaskClaimer {
    * @returns {Promise<Array>} 所有已认领的任务
    */
   async getAllClaimedTasks(projectPath) {
-    const specsPath = path.join(projectPath, '.kiro/specs');
+    const specsPath = path.join(projectPath, '.sce/specs');
     
     try {
       const exists = await fs.pathExists(specsPath);

package/lib/task/task-status-store.js

@@ -233,7 +233,7 @@ class TaskStatusStore {
    * @returns {string}
    */
   _tasksPath(specName) {
-    return path.join(this._workspaceRoot, '.kiro/specs', specName, 'tasks.md');
+    return path.join(this._workspaceRoot, '.sce/specs', specName, 'tasks.md');
   }
 
   /**
@@ -242,7 +242,7 @@ class TaskStatusStore {
    * @returns {string}
    */
   _lockPath(specName) {
-    return path.join(this._workspaceRoot, '.kiro/specs', specName, 'tasks.md.lock');
+    return path.join(this._workspaceRoot, '.sce/specs', specName, 'tasks.md.lock');
   }
 
   // ---------------------------------------------------------------------------

package/lib/templates/content-generalizer.js

@@ -152,7 +152,7 @@ class ContentGeneralizer {
     if (specMetadata.specPath) {
       replacements.push({
         pattern: new RegExp(this.escapeRegex(specMetadata.specPath), 'g'),
-        variable: '.kiro/specs/{{SPEC_NAME}}',
+        variable: '.sce/specs/{{SPEC_NAME}}',
         priority: 5,
         description: 'Spec path'
       });

package/lib/templates/spec-reader.js

@@ -1,5 +1,5 @@
 /**
- * SpecReader - Reads and validates Spec files from .kiro/specs/ directory
+ * SpecReader - Reads and validates Spec files from .sce/specs/ directory
  */
 
 const fs = require('fs').promises;
@@ -8,7 +8,7 @@ const { execSync } = require('child_process');
 
 class SpecReader {
   constructor() {
-    this.specsDir = '.kiro/specs';
+    this.specsDir = '.sce/specs';
   }
 
   /**

package/lib/templates/template-creator.js

@@ -180,7 +180,7 @@ class TemplateCreator {
 
       // Check for remaining project-specific content (high confidence patterns)
       const projectSpecificPatterns = [
-        /\.kiro\/specs\/\d+-\d+-[a-z-]+/g,  // Specific spec paths
+        /\.sce\/specs\/\d+-\d+-[a-z-]+/g,  // Specific spec paths
         /scene-capability-engine/g,  // Project name (unless it's the template itself)
       ];
 

package/lib/templates/template-exporter.js

@@ -7,7 +7,7 @@ const path = require('path');
 
 class TemplateExporter {
   constructor() {
-    this.defaultOutputDir = '.kiro/templates/exports';
+    this.defaultOutputDir = '.sce/templates/exports';
   }
 
   /**
@@ -177,7 +177,7 @@ Test your template locally before submitting:
 sce spec create test-spec --template ${metadata.name}
 
 # Verify the generated Spec is correct
-cd .kiro/specs/test-spec
+cd .sce/specs/test-spec
 # Check that variables were replaced correctly
 \`\`\`
 
@@ -404,7 +404,7 @@ sce templates show ${metadata.category}/${metadata.name}
 sce spec create my-new-feature --template ${metadata.category}/${metadata.name}
 \`\`\`
 
-This will create a new Spec at \`.kiro/specs/XX-00-my-new-feature/\` with:
+This will create a new Spec at \`.sce/specs/XX-00-my-new-feature/\` with:
 - \`requirements.md\` - Requirements document
 - \`design.md\` - Design document
 - \`tasks.md\` - Implementation tasks

package/lib/templates/template-manager.js

@@ -716,7 +716,7 @@ class TemplateManager {
     }
 
     // Determine target directory
-    const targetDir = path.join(process.cwd(), '.kiro', 'specs', specName);
+    const targetDir = path.join(process.cwd(), '.sce', 'specs', specName);
 
     // Apply template
     const result = await this.applicator.applyTemplate(

package/lib/upgrade/migration-engine.js

@@ -299,12 +299,12 @@ class MigrationEngine {
     const warnings = [];
     
     try {
-      // Check if .kiro/ directory exists
-      const kiroPath = path.join(projectPath, '.kiro');
+      // Check if .sce/ directory exists
+      const kiroPath = path.join(projectPath, '.sce');
       const kiroExists = await pathExists(kiroPath);
       
       if (!kiroExists) {
-        errors.push('.kiro/ directory not found');
+        errors.push('.sce/ directory not found');
         return { success: false, errors, warnings };
       }
       

package/lib/upgrade/migrations/1.0.0-to-1.1.0.js

@@ -26,7 +26,7 @@ module.exports = {
     const changes = [];
     
     try {
-      const kiroPath = path.join(projectPath, '.kiro');
+      const kiroPath = path.join(projectPath, '.sce');
       
       // 1. Ensure backups/ directory exists
       const backupsPath = path.join(kiroPath, 'backups');

package/lib/utils/file-diff.js

@@ -157,12 +157,12 @@ class FileDiff {
    */
   async compareSteeringFiles(projectRoot, templateRoot) {
     const steeringFiles = [
-      '.kiro/steering/CORE_PRINCIPLES.md',
-      '.kiro/steering/ENVIRONMENT.md',
-      '.kiro/steering/CURRENT_CONTEXT.md',
-      '.kiro/steering/RULES_GUIDE.md',
-      '.kiro/specs/SPEC_WORKFLOW_GUIDE.md',
-      '.kiro/README.md'
+      '.sce/steering/CORE_PRINCIPLES.md',
+      '.sce/steering/ENVIRONMENT.md',
+      '.sce/steering/CURRENT_CONTEXT.md',
+      '.sce/steering/RULES_GUIDE.md',
+      '.sce/specs/SPEC_WORKFLOW_GUIDE.md',
+      '.sce/README.md'
     ];
     
     const filePairs = steeringFiles.map(file => ({

package/lib/utils/tool-detector.js

@@ -63,19 +63,19 @@ async function detectKiroIDE(projectPath) {
   let detected = false;
   let confidence = 'low';
 
-  // Check for .kiro directory
-  const kiroDir = path.join(projectPath, '.kiro');
+  // Check for .sce directory
+  const kiroDir = path.join(projectPath, '.sce');
   if (await fs.pathExists(kiroDir)) {
-    indicators.push('.kiro directory exists');
+    indicators.push('.sce directory exists');
     detected = true;
     confidence = 'medium';
   }
 
   // Check for SCE-specific files
   const kiroFiles = [
-    '.kiro/steering',
-    '.kiro/specs',
-    '.kiro/tools'
+    '.sce/steering',
+    '.sce/specs',
+    '.sce/tools'
   ];
 
   for (const file of kiroFiles) {
@@ -87,7 +87,7 @@ async function detectKiroIDE(projectPath) {
   }
 
   // Check for environment variables (if running in SCE)
-  if (process.env.KIRO_IDE === 'true' || process.env.KIRO_VERSION) {
+  if (process.env.sce_IDE === 'true' || process.env.sce_VERSION) {
     indicators.push('SCE environment variables detected');
     detected = true;
     confidence = 'high';
@@ -215,7 +215,7 @@ function getRecommendations(primaryTool, detections) {
         type: 'native',
         title: 'Use SCE Agent Hooks',
         description: 'You can use native SCE agent hooks for seamless automation',
-        action: 'Configure hooks in .kiro/hooks/'
+        action: 'Configure hooks in .sce/hooks/'
       });
       recommendations.push({
         type: 'optional',
@@ -317,7 +317,7 @@ async function generateAutoConfig(detection, projectPath) {
     case 'SCE':
       config.suggestedPresets = [];
       config.suggestedCommands = [
-        'Use native SCE agent hooks (see .kiro/hooks/)',
+        'Use native SCE agent hooks (see .sce/hooks/)',
         'Optional: sce watch init (for watch mode fallback)'
       ];
       config.notes.push('AI IDE detected - native hooks are recommended');
@@ -332,7 +332,7 @@ async function generateAutoConfig(detection, projectPath) {
         'sce watch install auto-sync',
         'sce watch start'
       ];
-      config.configPath = path.join(projectPath, '.kiro/watch-config.json');
+      config.configPath = path.join(projectPath, '.sce/watch-config.json');
       config.notes.push(`${primaryTool === 'vscode' ? 'VS Code' : 'Cursor'} detected - watch mode recommended`);
       config.notes.push('Run suggested commands to set up automation');
       break;

package/lib/utils/validation.js

@@ -21,12 +21,12 @@ async function validateProjectStructure(projectPath) {
   const warnings = [];
   
   try {
-    const kiroPath = path.join(projectPath, '.kiro');
+    const kiroPath = path.join(projectPath, '.sce');
     
-    // Check if .kiro/ directory exists
+    // Check if .sce/ directory exists
     const kiroExists = await pathExists(kiroPath);
     if (!kiroExists) {
-      errors.push('.kiro/ directory not found');
+      errors.push('.sce/ directory not found');
       return { success: false, errors, warnings };
     }
     
@@ -110,7 +110,7 @@ async function validateVersionFile(projectPath) {
   const warnings = [];
   
   try {
-    const versionPath = path.join(projectPath, '.kiro', 'version.json');
+    const versionPath = path.join(projectPath, '.sce', 'version.json');
     
     // Check if version.json exists
     const exists = await pathExists(versionPath);
@@ -190,7 +190,7 @@ async function validateDependencies(projectPath) {
     }
     
     // Check Python version (if Ultrawork tools are present)
-    const toolPath = path.join(projectPath, '.kiro/tools/ultrawork_enhancer.py');
+    const toolPath = path.join(projectPath, '.sce/tools/ultrawork_enhancer.py');
     const toolExists = await pathExists(toolPath);
     
     if (toolExists) {

package/lib/value/metric-contract-loader.js

@@ -49,7 +49,7 @@ class MetricContractLoader {
   getDefaultPath() {
     return path.join(
       this.projectPath,
-      '.kiro',
+      '.sce',
       'specs',
       '112-00-spec-value-realization-program',
       'custom',

package/lib/version/version-manager.js

@@ -32,7 +32,7 @@ class VersionManager {
    * @returns {string} - Absolute path to version.json
    */
   getVersionFilePath(projectPath) {
-    return path.join(projectPath, '.kiro', this.versionFileName);
+    return path.join(projectPath, '.sce', this.versionFileName);
   }
 
   /**

package/lib/watch/execution-logger.js

@@ -12,7 +12,7 @@ class ExecutionLogger extends EventEmitter {
     super();
     
     this.config = {
-      logDir: config.logDir || '.kiro/watch/logs',
+      logDir: config.logDir || '.sce/watch/logs',
       logFile: config.logFile || 'execution.log',
       maxLogSize: config.maxLogSize || 10 * 1024 * 1024, // 10MB
       maxLogFiles: config.maxLogFiles || 5,

package/lib/watch/presets.js

@@ -33,17 +33,17 @@ const promptRegenPreset = {
   name: 'prompt-regen',
   description: 'Regenerate prompts when requirements or design changes',
   patterns: [
-    '**/.kiro/specs/*/requirements.md',
-    '**/.kiro/specs/*/design.md'
+    '**/.sce/specs/*/requirements.md',
+    '**/.sce/specs/*/design.md'
   ],
   actions: {
-    '**/.kiro/specs/*/requirements.md': {
+    '**/.sce/specs/*/requirements.md': {
       command: 'sce prompt regenerate ${spec}',
       debounce: 5000,
       retry: true,
       description: 'Regenerate prompts when requirements change'
     },
-    '**/.kiro/specs/*/design.md': {
+    '**/.sce/specs/*/design.md': {
       command: 'sce prompt regenerate ${spec}',
       debounce: 5000,
       retry: true,
@@ -53,8 +53,8 @@ const promptRegenPreset = {
   debounce: {
     default: 5000,
     perPattern: {
-      '**/.kiro/specs/*/requirements.md': 5000,
-      '**/.kiro/specs/*/design.md': 5000
+      '**/.sce/specs/*/requirements.md': 5000,
+      '**/.sce/specs/*/design.md': 5000
     }
   }
 };
@@ -66,9 +66,9 @@ const promptRegenPreset = {
 const contextExportPreset = {
   name: 'context-export',
   description: 'Export context when work is complete',
-  patterns: ['**/.kiro/specs/*/.complete'],
+  patterns: ['**/.sce/specs/*/.complete'],
   actions: {
-    '**/.kiro/specs/*/.complete': {
+    '**/.sce/specs/*/.complete': {
       command: 'sce context export ${spec}',
       debounce: 1000,
       retry: true,

package/lib/watch/watch-manager.js

@@ -16,7 +16,7 @@ class WatchManager extends EventEmitter {
     super();
     
     this.config = {
-      configFile: config.configFile || '.kiro/watch-config.json',
+      configFile: config.configFile || '.sce/watch-config.json',
       basePath: config.basePath || process.cwd(),
       autoStart: config.autoStart !== false,
       ...config
@@ -150,7 +150,7 @@ class WatchManager extends EventEmitter {
   async _initializeComponents() {
     // 1. 初始化 logger
     this.logger = new ExecutionLogger({
-      logDir: path.join(this.config.basePath, '.kiro/watch/logs'),
+      logDir: path.join(this.config.basePath, '.sce/watch/logs'),
       logLevel: this.watchConfig.logging?.level || 'info',
       maxLogSize: this._parseSize(this.watchConfig.logging?.maxSize || '10MB'),
       enableRotation: this.watchConfig.logging?.rotation !== false

package/lib/workspace/legacy-kiro-migrator.js

@@ -0,0 +1,275 @@
+const fs = require('fs-extra');
+const path = require('path');
+
+const LEGACY_DIRNAME = '.kiro';
+const TARGET_DIRNAME = '.sce';
+const DEFAULT_MAX_DEPTH = 6;
+const DEFAULT_IGNORE_DIRS = new Set([
+  '.git',
+  'node_modules',
+  TARGET_DIRNAME,
+  'dist',
+  'build',
+  'coverage',
+  '.next',
+]);
+
+async function findLegacyKiroDirectories(rootDir, options = {}) {
+  const maxDepth = Number.isInteger(options.maxDepth) ? options.maxDepth : DEFAULT_MAX_DEPTH;
+  const ignoreDirs = options.ignoreDirs instanceof Set
+    ? options.ignoreDirs
+    : DEFAULT_IGNORE_DIRS;
+  const results = [];
+
+  async function walk(currentDir, depth) {
+    if (depth > maxDepth) {
+      return;
+    }
+    let entries;
+    try {
+      entries = await fs.readdir(currentDir, { withFileTypes: true });
+    } catch (_error) {
+      return;
+    }
+
+    for (const entry of entries) {
+      if (!entry.isDirectory()) {
+        continue;
+      }
+      const fullPath = path.join(currentDir, entry.name);
+      if (entry.name === LEGACY_DIRNAME) {
+        results.push(fullPath);
+        continue;
+      }
+      if (ignoreDirs.has(entry.name)) {
+        continue;
+      }
+      await walk(fullPath, depth + 1);
+    }
+  }
+
+  await walk(rootDir, 0);
+  results.sort((a, b) => a.length - b.length);
+  return results;
+}
+
+async function migrateLegacyKiroDirectories(rootDir, options = {}) {
+  const dryRun = options.dryRun === true;
+  const legacyDirs = await findLegacyKiroDirectories(rootDir, options);
+  const report = {
+    root: rootDir,
+    dryRun,
+    scanned: legacyDirs.length,
+    migrated: 0,
+    renamed: 0,
+    merged: 0,
+    moved_files: 0,
+    deduped_files: 0,
+    conflict_files: 0,
+    details: [],
+  };
+
+  // Deepest first avoids parent directory interactions in nested projects.
+  const ordered = [...legacyDirs].sort((a, b) => b.length - a.length);
+  for (const legacyDir of ordered) {
+    const detail = await _migrateSingleLegacyDirectory(legacyDir, { dryRun });
+    report.details.push(detail);
+    if (!detail.success) {
+      continue;
+    }
+    report.migrated += 1;
+    report.renamed += detail.action === 'rename' ? 1 : 0;
+    report.merged += detail.action === 'merge' ? 1 : 0;
+    report.moved_files += detail.moved_files || 0;
+    report.deduped_files += detail.deduped_files || 0;
+    report.conflict_files += detail.conflict_files || 0;
+  }
+
+  return report;
+}
+
+async function autoMigrateLegacyKiroDirectories(rootDir, options = {}) {
+  const dryRun = options.dryRun === true;
+  const report = await migrateLegacyKiroDirectories(rootDir, {
+    ...options,
+    dryRun,
+  });
+  return {
+    detected: report.scanned,
+    migrated: report.migrated,
+    report,
+  };
+}
+
+async function _migrateSingleLegacyDirectory(legacyDir, options) {
+  const dryRun = options.dryRun === true;
+  const parentDir = path.dirname(legacyDir);
+  const targetDir = path.join(parentDir, TARGET_DIRNAME);
+  const detail = {
+    source: legacyDir,
+    target: targetDir,
+    success: true,
+    action: 'rename',
+    moved_files: 0,
+    deduped_files: 0,
+    conflict_files: 0,
+    errors: [],
+  };
+
+  try {
+    const targetExists = await fs.pathExists(targetDir);
+    if (!targetExists) {
+      if (!dryRun) {
+        await fs.move(legacyDir, targetDir, { overwrite: false });
+      }
+      return detail;
+    }
+
+    detail.action = 'merge';
+    const mergeReport = await _mergeLegacyIntoTarget(legacyDir, targetDir, { dryRun });
+    detail.moved_files = mergeReport.moved_files;
+    detail.deduped_files = mergeReport.deduped_files;
+    detail.conflict_files = mergeReport.conflict_files;
+    detail.errors.push(...mergeReport.errors);
+    detail.success = mergeReport.errors.length === 0;
+    return detail;
+  } catch (error) {
+    detail.success = false;
+    detail.errors.push(error.message);
+    return detail;
+  }
+}
+
+async function _mergeLegacyIntoTarget(legacyDir, targetDir, options) {
+  const dryRun = options.dryRun === true;
+  const report = {
+    moved_files: 0,
+    deduped_files: 0,
+    conflict_files: 0,
+    errors: [],
+  };
+  const files = await _listFilesRecursive(legacyDir);
+
+  for (const sourcePath of files) {
+    const relative = path.relative(legacyDir, sourcePath);
+    const targetPath = path.join(targetDir, relative);
+    try {
+      const targetExists = await fs.pathExists(targetPath);
+      if (!targetExists) {
+        report.moved_files += 1;
+        if (!dryRun) {
+          await fs.ensureDir(path.dirname(targetPath));
+          await fs.move(sourcePath, targetPath, { overwrite: false });
+        }
+        continue;
+      }
+
+      const same = await _isSameFile(sourcePath, targetPath);
+      if (same) {
+        report.deduped_files += 1;
+        if (!dryRun) {
+          await fs.remove(sourcePath);
+        }
+        continue;
+      }
+
+      const conflictPath = await _nextConflictPath(targetPath);
+      report.conflict_files += 1;
+      if (!dryRun) {
+        await fs.ensureDir(path.dirname(conflictPath));
+        await fs.move(sourcePath, conflictPath, { overwrite: false });
+      }
+    } catch (error) {
+      report.errors.push(`${sourcePath}: ${error.message}`);
+    }
+  }
+
+  if (!dryRun) {
+    await _removeEmptyDirectories(legacyDir);
+    if (await fs.pathExists(legacyDir)) {
+      const remaining = await fs.readdir(legacyDir);
+      if (remaining.length === 0) {
+        await fs.remove(legacyDir);
+      }
+    }
+  }
+
+  return report;
+}
+
+async function _listFilesRecursive(rootDir) {
+  const files = [];
+
+  async function walk(currentDir) {
+    let entries = [];
+    try {
+      entries = await fs.readdir(currentDir, { withFileTypes: true });
+    } catch (_error) {
+      return;
+    }
+    for (const entry of entries) {
+      const fullPath = path.join(currentDir, entry.name);
+      if (entry.isDirectory()) {
+        await walk(fullPath);
+      } else if (entry.isFile()) {
+        files.push(fullPath);
+      }
+    }
+  }
+
+  await walk(rootDir);
+  return files;
+}
+
+async function _isSameFile(leftPath, rightPath) {
+  const [leftBuffer, rightBuffer] = await Promise.all([
+    fs.readFile(leftPath),
+    fs.readFile(rightPath),
+  ]);
+  return leftBuffer.equals(rightBuffer);
+}
+
+async function _nextConflictPath(targetPath) {
+  const { dir, name, ext } = path.parse(targetPath);
+  let counter = 1;
+  while (true) {
+    const candidate = path.join(dir, `${name}.legacy-kiro-${counter}${ext}`);
+    if (!await fs.pathExists(candidate)) {
+      return candidate;
+    }
+    counter += 1;
+  }
+}
+
+async function _removeEmptyDirectories(rootDir) {
+  let entries = [];
+  try {
+    entries = await fs.readdir(rootDir, { withFileTypes: true });
+  } catch (_error) {
+    return;
+  }
+  for (const entry of entries) {
+    if (!entry.isDirectory()) {
+      continue;
+    }
+    const fullPath = path.join(rootDir, entry.name);
+    await _removeEmptyDirectories(fullPath);
+    try {
+      const childEntries = await fs.readdir(fullPath);
+      if (childEntries.length === 0) {
+        await fs.rmdir(fullPath);
+      }
+    } catch (_error) {
+      // Ignore delete race/errors.
+    }
+  }
+}
+
+module.exports = {
+  LEGACY_DIRNAME,
+  TARGET_DIRNAME,
+  findLegacyKiroDirectories,
+  migrateLegacyKiroDirectories,
+  autoMigrateLegacyKiroDirectories,
+};
+