scene-capability-engine 3.3.4 → 3.3.10

package/lib/commands/session.js

@@ -0,0 +1,139 @@
+const chalk = require('chalk');
+const { SessionStore } = require('../runtime/session-store');
+
+function registerSessionCommands(program) {
+  const session = program
+    .command('session')
+    .description('Manage universal runtime sessions (start/resume/snapshot)');
+
+  session
+    .command('start [objective]')
+    .description('Start a new SCE runtime session')
+    .option('--tool <tool>', 'Target tool (codex|claude|cursor|generic)', 'generic')
+    .option('--agent-version <version>', 'Target agent version for compatibility tracking')
+    .option('--id <id>', 'Custom session id')
+    .option('--json', 'Output as JSON')
+    .action(async (objective, options) => {
+      try {
+        const store = new SessionStore(process.cwd());
+        const created = await store.startSession({
+          tool: options.tool,
+          agentVersion: options.agentVersion,
+          objective: objective || '',
+          sessionId: options.id,
+        });
+        _printSessionResult('session_start', created, options.json);
+      } catch (error) {
+        _exitWithError(error, options.json);
+      }
+    });
+
+  session
+    .command('resume [sessionRef]')
+    .description('Resume a session by id, or use latest by default')
+    .option('--status <status>', 'Status to set after resume', 'active')
+    .option('--json', 'Output as JSON')
+    .action(async (sessionRef, options) => {
+      try {
+        const store = new SessionStore(process.cwd());
+        const resumed = await store.resumeSession(sessionRef || 'latest', {
+          status: options.status,
+        });
+        _printSessionResult('session_resume', resumed, options.json);
+      } catch (error) {
+        _exitWithError(error, options.json);
+      }
+    });
+
+  session
+    .command('snapshot [sessionRef]')
+    .description('Create a session snapshot by id, or use latest by default')
+    .option('--summary <summary>', 'Snapshot summary text', '')
+    .option('--status <status>', 'Session status after snapshot')
+    .option('--payload <json>', 'Optional JSON payload')
+    .option('--json', 'Output as JSON')
+    .action(async (sessionRef, options) => {
+      try {
+        const store = new SessionStore(process.cwd());
+        const payload = _parsePayload(options.payload);
+        const snapshotted = await store.snapshotSession(sessionRef || 'latest', {
+          summary: options.summary,
+          status: options.status,
+          payload,
+        });
+        _printSessionResult('session_snapshot', snapshotted, options.json);
+      } catch (error) {
+        _exitWithError(error, options.json);
+      }
+    });
+
+  session
+    .command('show [sessionRef]')
+    .description('Show a session by id, or latest by default')
+    .option('--json', 'Output as JSON')
+    .action(async (sessionRef, options) => {
+      try {
+        const store = new SessionStore(process.cwd());
+        const current = await store.getSession(sessionRef || 'latest');
+        _printSessionResult('session_show', current, options.json);
+      } catch (error) {
+        _exitWithError(error, options.json);
+      }
+    });
+}
+
+function _parsePayload(raw) {
+  if (raw == null || `${raw}`.trim() === '') {
+    return null;
+  }
+  try {
+    return JSON.parse(raw);
+  } catch (_error) {
+    throw new Error('Invalid --payload JSON');
+  }
+}
+
+function _printSessionResult(action, session, asJson = false) {
+  if (asJson) {
+    console.log(JSON.stringify({
+      success: true,
+      action,
+      session,
+    }, null, 2));
+    return;
+  }
+
+  const snapshots = Array.isArray(session.snapshots) ? session.snapshots.length : 0;
+  console.log(chalk.green('✓ Session updated'));
+  console.log(chalk.gray(`Session: ${session.session_id}`));
+  console.log(chalk.gray(`Tool: ${session.tool}`));
+  if (session.agent_version) {
+    console.log(chalk.gray(`Agent version: ${session.agent_version}`));
+  }
+  console.log(chalk.gray(`Status: ${session.status}`));
+  console.log(chalk.gray(`Snapshots: ${snapshots}`));
+  if (session.steering && session.steering.compatibility) {
+    const supported = session.steering.compatibility.supported;
+    const label = supported === null ? 'unknown' : supported;
+    console.log(chalk.gray(`Compatibility: ${label} (${session.steering.compatibility.rule})`));
+  }
+  if (session.objective) {
+    console.log(chalk.gray(`Objective: ${session.objective}`));
+  }
+}
+
+function _exitWithError(error, asJson = false) {
+  if (asJson) {
+    console.log(JSON.stringify({
+      success: false,
+      error: error.message,
+    }, null, 2));
+  } else {
+    console.error(chalk.red('Error:'), error.message);
+  }
+  process.exit(1);
+}
+
+module.exports = {
+  registerSessionCommands,
+};

package/lib/commands/spec-bootstrap.js

@@ -65,7 +65,7 @@ async function runSpecBootstrap(options = {}, dependencies = {}) {
     answers
   });
 
-  const specPath = path.join(projectPath, '.kiro', 'specs', specName);
+  const specPath = path.join(projectPath, '.sce', 'specs', specName);
   const files = {
     requirements: path.join(specPath, 'requirements.md'),
     design: path.join(specPath, 'design.md'),

package/lib/commands/spec-gate.js

@@ -35,7 +35,7 @@ async function runSpecGate(options = {}, dependencies = {}) {
 
   const specId = specTargets[0];
 
-  const specPath = path.join(projectPath, '.kiro', 'specs', specId);
+  const specPath = path.join(projectPath, '.sce', 'specs', specId);
   if (!await fs.pathExists(specPath)) {
     throw new Error(`Spec not found: ${specId}`);
   }
@@ -73,7 +73,7 @@ async function generateSpecGatePolicyTemplate(options = {}, dependencies = {}) {
 
   const outputPath = options.out
     ? (path.isAbsolute(options.out) ? options.out : path.join(projectPath, options.out))
-    : path.join(projectPath, '.kiro', 'config', 'spec-gate-policy.template.json');
+    : path.join(projectPath, '.sce', 'config', 'spec-gate-policy.template.json');
 
   await fs.ensureDir(path.dirname(outputPath));
   await fs.writeJson(outputPath, template, { spaces: 2 });

package/lib/commands/spec-pipeline.js

@@ -32,7 +32,7 @@ async function runSpecPipeline(options = {}, dependencies = {}) {
 
   const specId = specTargets[0];
 
-  const specPath = path.join(projectPath, '.kiro', 'specs', specId);
+  const specPath = path.join(projectPath, '.sce', 'specs', specId);
   if (!await fs.pathExists(specPath)) {
     throw new Error(`Spec not found: ${specId}`);
   }

package/lib/commands/status.js

@@ -29,12 +29,12 @@ async function statusCommand(options = {}) {
   console.log();
   
   try {
-    // 1. Check if .kiro/ exists
-    const kiroPath = path.join(projectPath, '.kiro');
+    // 1. Check if .sce/ exists
+    const kiroPath = path.join(projectPath, '.sce');
     const kiroExists = await fs.pathExists(kiroPath);
     
     if (!kiroExists) {
-      console.log(chalk.yellow('⚠️  No .kiro/ directory found'));
+      console.log(chalk.yellow('⚠️  No .sce/ directory found'));
       console.log();
       console.log('This project has not been adopted yet.');
       console.log('Run ' + chalk.cyan('sce adopt') + ' to get started.');
@@ -64,7 +64,7 @@ async function statusCommand(options = {}) {
     await displayDocumentCompliance(projectPath);
     
     // 4. List specs
-    const specsPath = path.join(projectPath, '.kiro/specs');
+    const specsPath = path.join(projectPath, '.sce/specs');
     const specsExist = await fs.pathExists(specsPath);
     
     if (!specsExist) {

package/lib/commands/steering.js

@@ -0,0 +1,119 @@
+const fs = require('fs-extra');
+const path = require('path');
+const chalk = require('chalk');
+const { SteeringContract, normalizeToolName } = require('../runtime/steering-contract');
+
+function registerSteeringCommands(program) {
+  const steering = program
+    .command('steering')
+    .description('Manage universal steering contract for cross-agent runtime');
+
+  steering
+    .command('init')
+    .description('Initialize .sce steering contract')
+    .option('--json', 'Output as JSON')
+    .action(async (options) => {
+      try {
+        const contract = new SteeringContract(process.cwd());
+        const result = await contract.ensureContract();
+        if (options.json) {
+          console.log(JSON.stringify({
+            success: true,
+            action: 'steering_init',
+            ...result,
+          }, null, 2));
+          return;
+        }
+
+        console.log(chalk.green('✓ Steering contract initialized'));
+        console.log(chalk.gray(`Manifest: ${result.manifestPath}`));
+        if (result.preparedLayers.length > 0) {
+          console.log(chalk.gray('Layers:'));
+          for (const layer of result.preparedLayers) {
+            console.log(chalk.gray(`  - ${layer.layer} (${layer.file}) <= ${layer.source}`));
+          }
+        }
+      } catch (error) {
+        _exitWithError(error, options.json);
+      }
+    });
+
+  steering
+    .command('compile')
+    .description('Compile steering contract into an agent-specific runtime bundle')
+    .option('--tool <tool>', 'Target tool (codex|claude|cursor|generic)', 'codex')
+    .option('--agent-version <version>', 'Target agent version for compatibility check')
+    .option('--format <format>', 'Output format (markdown|json)', 'markdown')
+    .option('--out <path>', 'Output file path (default under .sce/steering/compiled)')
+    .option('--json', 'Output command result as JSON')
+    .action(async (options) => {
+      try {
+        const workspaceRoot = process.cwd();
+        const tool = normalizeToolName(options.tool || 'codex');
+        const format = _normalizeFormat(options.format);
+        const contract = new SteeringContract(workspaceRoot);
+        await contract.ensureContract();
+        const payload = await contract.buildCompilePayload(tool, options.agentVersion);
+
+        const outputPath = options.out
+          ? path.resolve(workspaceRoot, options.out)
+          : path.join(workspaceRoot, '.sce', 'steering', 'compiled', `steering-${tool}.${format === 'json' ? 'json' : 'md'}`);
+        await fs.ensureDir(path.dirname(outputPath));
+
+        if (format === 'json') {
+          await fs.writeJson(outputPath, payload, { spaces: 2 });
+        } else {
+          await fs.writeFile(outputPath, contract.renderMarkdown(payload), 'utf8');
+        }
+
+        const response = {
+          success: true,
+          action: 'steering_compile',
+          tool,
+          format,
+          agent_version: payload.agent_version,
+          source_mode: payload.source_mode,
+          compatibility: payload.compatibility,
+          output: path.relative(workspaceRoot, outputPath).replace(/\\/g, '/'),
+        };
+
+        if (options.json) {
+          console.log(JSON.stringify(response, null, 2));
+          return;
+        }
+
+        console.log(chalk.green('✓ Steering compiled'));
+        console.log(chalk.gray(`Tool: ${tool}`));
+        console.log(chalk.gray(`Format: ${format}`));
+        console.log(chalk.gray(`Source mode: ${payload.source_mode}`));
+        console.log(chalk.gray(`Compatibility: ${payload.compatibility.supported === null ? 'unknown' : payload.compatibility.supported} (${payload.compatibility.rule})`));
+        console.log(chalk.gray(`Output: ${response.output}`));
+      } catch (error) {
+        _exitWithError(error, options.json);
+      }
+    });
+}
+
+function _normalizeFormat(format) {
+  const normalized = `${format || 'markdown'}`.trim().toLowerCase();
+  if (normalized === 'json') {
+    return 'json';
+  }
+  return 'markdown';
+}
+
+function _exitWithError(error, asJson = false) {
+  if (asJson) {
+    console.log(JSON.stringify({
+      success: false,
+      error: error.message,
+    }, null, 2));
+  } else {
+    console.error(chalk.red('Error:'), error.message);
+  }
+  process.exit(1);
+}
+
+module.exports = {
+  registerSteeringCommands,
+};

package/lib/commands/value.js

@@ -139,7 +139,7 @@ function resolveMetricInput(inputPayload) {
 function defaultHistoryDir(projectPath) {
   return path.join(
     projectPath,
-    '.kiro',
+    '.sce',
     'specs',
     '114-00-kpi-automation-and-observability',
     'custom',

package/lib/commands/watch.js

@@ -21,7 +21,7 @@ const { listPresets, getPreset, mergePreset, validatePreset } = require('../watc
  */
 async function startWatch(options = {}) {
   const projectPath = process.cwd();
-  const configPath = options.config || path.join(projectPath, '.kiro/watch-config.json');
+  const configPath = options.config || path.join(projectPath, '.sce/watch-config.json');
   
   console.log(chalk.red('🔥') + ' Starting Watch Mode');
   console.log();
@@ -87,7 +87,7 @@ async function startWatch(options = {}) {
  */
 async function stopWatch(options = {}) {
   const projectPath = process.cwd();
-  const configPath = path.join(projectPath, '.kiro/watch-config.json');
+  const configPath = path.join(projectPath, '.sce/watch-config.json');
   
   console.log(chalk.red('🔥') + ' Stopping Watch Mode');
   console.log();
@@ -114,7 +114,7 @@ async function stopWatch(options = {}) {
  */
 async function statusWatch(options = {}) {
   const projectPath = process.cwd();
-  const configPath = path.join(projectPath, '.kiro/watch-config.json');
+  const configPath = path.join(projectPath, '.sce/watch-config.json');
   
   console.log(chalk.red('🔥') + ' Watch Mode Status');
   console.log();
@@ -244,7 +244,7 @@ function resolveWatchLogPath(projectPath, options = {}) {
   }
 
   const logFile = options.logFile || 'execution.log';
-  return path.join(projectPath, '.kiro', 'watch', 'logs', logFile);
+  return path.join(projectPath, '.sce', 'watch', 'logs', logFile);
 }
 
 async function readRawLogLines(logPath) {
@@ -345,7 +345,7 @@ async function followLogStream(logPath, options = {}) {
  */
 async function metricsWatch(options = {}) {
   const projectPath = process.cwd();
-  const configPath = path.join(projectPath, '.kiro/watch-config.json');
+  const configPath = path.join(projectPath, '.sce/watch-config.json');
   
   console.log(chalk.red('🔥') + ' Watch Mode Metrics');
   console.log();
@@ -405,7 +405,7 @@ async function metricsWatch(options = {}) {
  */
 async function initWatch(options = {}) {
   const projectPath = process.cwd();
-  const configPath = path.join(projectPath, '.kiro/watch-config.json');
+  const configPath = path.join(projectPath, '.sce/watch-config.json');
   
   console.log(chalk.red('🔥') + ' Initialize Watch Configuration');
   console.log();
@@ -426,8 +426,8 @@ async function initWatch(options = {}) {
       enabled: true,
       patterns: [
         '**/tasks.md',
-        '**/.kiro/specs/*/requirements.md',
-        '**/.kiro/specs/*/design.md'
+        '**/.sce/specs/*/requirements.md',
+        '**/.sce/specs/*/design.md'
       ],
       ignored: [
         '**/node_modules/**',
@@ -550,7 +550,7 @@ async function listPresetsWatch(options = {}) {
  */
 async function installPresetWatch(presetName, options = {}) {
   const projectPath = process.cwd();
-  const configPath = path.join(projectPath, '.kiro/watch-config.json');
+  const configPath = path.join(projectPath, '.sce/watch-config.json');
   
   console.log(chalk.red('🔥') + ` Installing Preset: ${chalk.cyan(presetName)}`);
   console.log();

package/lib/commands/workspace-multi.js

@@ -274,7 +274,7 @@ async function infoWorkspace(name = null, options = {}) {
     // Count Specs in workspace
     let specCount = 0;
     try {
-      const specsPath = path.join(workspace.getPlatformPath(), '.kiro', 'specs');
+      const specsPath = path.join(workspace.getPlatformPath(), '.sce', 'specs');
       const exists = await fs.pathExists(specsPath);
       
       if (exists) {

package/lib/context/context-exporter.js

@@ -29,7 +29,7 @@ class ContextExporter {
     } = options;
 
     try {
-      const specPath = path.join(projectPath, '.kiro/specs', specName);
+      const specPath = path.join(projectPath, '.sce/specs', specName);
       
       // 检查 Spec 是否存在
       const specExists = await fs.pathExists(specPath);
@@ -183,15 +183,13 @@ ${content}`;
    * @returns {Promise<string>} Steering 内容
    */
   async includeSteeringRules(projectPath, steeringFiles) {
-    const steeringPath = path.join(projectPath, '.kiro/steering');
+    const steeringRoot = path.join(projectPath, '.sce/steering');
     const sections = ['## Steering Rules\n'];
 
     for (const fileName of steeringFiles) {
-      const filePath = path.join(steeringPath, fileName);
-      
       try {
-        const exists = await fs.pathExists(filePath);
-        if (!exists) {
+        const filePath = path.join(steeringRoot, fileName);
+        if (!await fs.pathExists(filePath)) {
           continue;
         }
 
@@ -264,7 +262,7 @@ If you encounter issues:
    */
   async generateTaskContext(projectPath, specName, taskId) {
     try {
-      const specPath = path.join(projectPath, '.kiro/specs', specName);
+      const specPath = path.join(projectPath, '.sce/specs', specName);
 
       // 读取所有文件
       const requirements = await this.readSpecFile(specPath, 'requirements.md');

package/lib/context/prompt-generator.js

@@ -28,7 +28,7 @@ class PromptGenerator {
     } = options;
 
     try {
-      const specPath = path.join(projectPath, '.kiro/specs', specName);
+      const specPath = path.join(projectPath, '.sce/specs', specName);
       
       // 检查 Spec 是否存在
       const specExists = await fs.pathExists(specPath);
@@ -449,7 +449,7 @@ class PromptGenerator {
   getToolSpecificNotes(targetTool) {
     const notes = {
       'generic': 'This prompt is compatible with any AI coding assistant.',
-      'claude-code': 'Use this prompt with Claude Code by copying it into the chat.',
+      'claude-code': 'Use this prompt with Claude Code by copying it into the chat (recommended launch: claude --dangerously-skip-permission).',
       'cursor': 'Use this prompt with Cursor by pasting it into the composer.',
       'codex': 'Use this prompt with GitHub Copilot by including it in your code comments.',
       'SCE': 'This prompt is optimized for AI IDE with automatic steering loading.'

package/lib/environment/backup-system.js

@@ -14,7 +14,7 @@ class BackupSystem {
    */
   constructor(projectRoot) {
     this.projectRoot = projectRoot;
-    this.backupDir = path.join(projectRoot, '.kiro', 'env-backups');
+    this.backupDir = path.join(projectRoot, '.sce', 'env-backups');
   }
 
   /**

package/lib/environment/environment-manager.js

@@ -30,13 +30,13 @@ class EnvironmentManager {
     if (this.workspaceContext) {
       return path.join(
         this.projectRoot,
-        '.kiro',
+        '.sce',
         'workspaces',
         this.workspaceContext,
         'environments.json'
       );
     }
-    return path.join(this.projectRoot, '.kiro', 'environments.json');
+    return path.join(this.projectRoot, '.sce', 'environments.json');
   }
 
   /**

package/lib/gitignore/gitignore-backup.js

@@ -51,7 +51,7 @@ class GitignoreBackup {
     const backupId = `gitignore-${timestamp}`;
     
     // Create backup directory
-    const backupDir = path.join(projectPath, '.kiro', 'backups');
+    const backupDir = path.join(projectPath, '.sce', 'backups');
     await fs.ensureDir(backupDir);
     
     // Write backup file
@@ -90,7 +90,7 @@ class GitignoreBackup {
    * @returns {Promise<RestoreResult>}
    */
   async restore(projectPath, backupId) {
-    const backupDir = path.join(projectPath, '.kiro', 'backups');
+    const backupDir = path.join(projectPath, '.sce', 'backups');
     const backupPath = path.join(backupDir, backupId);
     const metaPath = path.join(backupDir, `${backupId}.meta.json`);
     
@@ -135,7 +135,7 @@ class GitignoreBackup {
    * @returns {Promise<BackupInfo[]>}
    */
   async listBackups(projectPath) {
-    const backupDir = path.join(projectPath, '.kiro', 'backups');
+    const backupDir = path.join(projectPath, '.sce', 'backups');
     
     if (!await fs.pathExists(backupDir)) {
       return [];

package/lib/gitignore/gitignore-detector.js

@@ -10,10 +10,10 @@ const path = require('path');
 
 /**
  * @typedef {Object} GitignoreRule
- * @property {string} pattern - Rule pattern (e.g., '.kiro/backups/')
+ * @property {string} pattern - Rule pattern (e.g., '.sce/backups/')
  * @property {string} type - 'exclusion' | 'negation' | 'comment'
  * @property {number} line - Line number in file
- * @property {boolean} isKiroRelated - Rule relates to .kiro/
+ * @property {boolean} isKiroRelated - Rule relates to .sce/
  * @property {boolean} isManaged - Rule is in sce-managed section
  */
 
@@ -31,19 +31,19 @@ class GitignoreDetector {
   constructor() {
     // Old patterns that indicate blanket exclusion
     this.OLD_PATTERNS = [
-      /^\.kiro\/?\s*$/,           // .kiro/ or .kiro
-      /^\.kiro\/\*\s*$/,          // .kiro/*
-      /^\.kiro\/\*\*\s*$/         // .kiro/**
+      /^\.sce\/?\s*$/,           // .sce/ or .sce
+      /^\.sce\/\*\s*$/,          // .sce/*
+      /^\.sce\/\*\*\s*$/         // .sce/**
     ];
     
     // Required layered rules (key patterns to check)
     this.REQUIRED_RULES = [
-      '.kiro/steering/CURRENT_CONTEXT.md',
-      '.kiro/contexts/.active',
-      '.kiro/environments.json',
-      '.kiro/backups/',
-      '.kiro/logs/',
-      '.kiro/reports/'
+      '.sce/steering/CURRENT_CONTEXT.md',
+      '.sce/contexts/.active',
+      '.sce/environments.json',
+      '.sce/backups/',
+      '.sce/logs/',
+      '.sce/reports/'
     ];
   }
 
@@ -151,8 +151,8 @@ class GitignoreDetector {
         return; // Skip blank lines
       }
       
-      // Check if .kiro-related
-      const isKiroRelated = pattern.includes('.kiro');
+      // Check if .sce-related
+      const isKiroRelated = pattern.includes('.sce');
       
       rules.push({
         pattern: trimmed,

package/lib/gitignore/gitignore-integration.js

@@ -167,7 +167,7 @@ class GitignoreIntegration {
     if (result.action === 'skipped') {
       console.log(chalk.green('✅ .gitignore is already optimal'));
       console.log();
-      console.log(chalk.gray('  Current strategy: Layered .kiro/ management'));
+      console.log(chalk.gray('  Current strategy: Layered .sce/ management'));
       console.log(chalk.gray('  - Specs are committable'));
       console.log(chalk.gray('  - Personal state is excluded'));
       console.log();
@@ -187,7 +187,7 @@ class GitignoreIntegration {
     
     if (result.backupId) {
       console.log(chalk.blue('📦 Backup created:'), result.backupId);
-      console.log(chalk.gray('  Location:'), `.kiro/backups/${result.backupId}`);
+      console.log(chalk.gray('  Location:'), `.sce/backups/${result.backupId}`);
       console.log();
     }
     
@@ -248,7 +248,7 @@ class GitignoreIntegration {
       console.log(chalk.yellow(`    - Removed ${result.removed.length} old pattern(s)`));
     }
     
-    console.log(chalk.green('    + Added layered .kiro/ exclusion rules'));
+    console.log(chalk.green('    + Added layered .sce/ exclusion rules'));
     console.log(chalk.green('    + Specs are now committable'));
     console.log(chalk.green('    + Personal state is excluded'));
     console.log();

package/lib/gitignore/gitignore-transformer.js

@@ -19,9 +19,9 @@ class GitignoreTransformer {
   constructor() {
     // Old patterns to remove
     this.OLD_PATTERNS = [
-      /^\.kiro\/?\s*$/,
-      /^\.kiro\/\*\s*$/,
-      /^\.kiro\/\*\*\s*$/
+      /^\.sce\/?\s*$/,
+      /^\.sce\/\*\s*$/,
+      /^\.sce\/\*\*\s*$/
     ];
   }
 
@@ -64,7 +64,7 @@ class GitignoreTransformer {
       lines.forEach(line => {
         const trimmed = line.trim();
         if (trimmed && !trimmed.startsWith('#') && !this.isOldPattern(trimmed)) {
-          if (!trimmed.includes('.kiro')) {
+          if (!trimmed.includes('.sce')) {
             result.preserved.push(trimmed);
           }
         }