sillyspec 3.11.8 → 3.11.10

package/src/hooks/worktree-guard.js

@@ -0,0 +1,488 @@
+/**
+ * worktree-guard.js — Hook 拦截判断逻辑
+ *
+ * 三重门禁：stageGate × locationGate × fileGate
+ * 纯判断模块，不做实际的 hook 注入。
+ */
+
+import { existsSync, readFileSync } from 'fs'
+import path from 'path'
+
+// ── 常量 ──
+
+const ALLOWED_STAGES = ['execute', 'quick']
+
+const WORKTREE_SEGMENT = '.sillyspec/.runtime/worktrees/'
+
+const FILE_WHITELIST_EXTS = ['.md']
+const FILE_WHITELIST_NAMES = ['package.json', 'tsconfig.json', 'local.yaml', 'local.yml']
+
+/** 只读命令（命令名） */
+const READONLY_COMMANDS = new Set([
+  'grep', 'rg', 'ag', 'find', 'ls', 'cat', 'head', 'tail', 'wc', 'stat',
+  'echo', 'pwd', 'basename', 'dirname', 'realpath',
+  'node', 'npm', 'npx', // 只允许 --version 等只读子命令，在 matchReadonlyWhitelist 中处理
+])
+
+/** 只读 git 子命令 */
+const READONLY_GIT_SUBS = new Set(['diff', 'status', 'log', 'show', 'branch', 'stash'])
+
+/** 危险 git 子命令 */
+const DANGER_GIT_SUBS = new Set([
+  'add', 'commit', 'push', 'checkout', 'restore', 'reset', 'clean',
+  'mv', 'rm',
+])
+
+/** 危险 git stash 操作 */
+const DANGER_STASH_ACTIONS = new Set(['drop', 'clear', 'pop'])
+
+/** 危险命令前缀 */
+const DANGER_PREFIXES = ['sudo', 'rm -rf', 'rm -r', 'rmdir']
+
+// ── 辅助函数 ──
+
+function resolveWorktreeDir(cwd) {
+  return path.join(cwd, '.sillyspec', '.runtime', 'worktrees')
+}
+
+/**
+ * 读取 gate-status.json
+ * @param {string} cwd
+ * @returns {{ stage: string, changes?: string[], updatedAt?: string } | null}
+ */
+function readGateStatus(cwd) {
+  const p = path.join(cwd, '.sillyspec', '.runtime', 'gate-status.json')
+  if (!existsSync(p)) return null
+  try {
+    return JSON.parse(readFileSync(p, 'utf8'))
+  } catch {
+    return null
+  }
+}
+
+/**
+ * 检查当前变更是否处于 noWorktree 模式
+ * @param {string} cwd
+ * @returns {boolean}
+ */
+function isNoWorktreeMode(cwd) {
+  // 1. 检查 gate-status.json
+  const gateStatus = readGateStatus(cwd)
+  if (gateStatus && gateStatus.noWorktree) return true
+
+  // 2. 检查 progress.json
+  const progressFiles = [
+    path.join(cwd, '.sillyspec', '.runtime', 'progress.json'),
+  ]
+  for (const p of progressFiles) {
+    if (!existsSync(p)) continue
+    try {
+      const data = JSON.parse(readFileSync(p, 'utf8'))
+      if (data.noWorktree) return true
+    } catch { /* skip */ }
+  }
+
+  // 3. 检查变更级 progress.json
+  const runtimeDir = path.join(cwd, '.sillyspec', '.runtime')
+  const globalFile = path.join(runtimeDir, 'global.json')
+  if (existsSync(globalFile)) {
+    try {
+      const global = JSON.parse(readFileSync(globalFile, 'utf8'))
+      const changesDir = path.join(cwd, '.sillyspec', 'changes')
+      for (const cn of (global.activeChanges || [])) {
+        const pp = path.join(changesDir, cn, 'progress.json')
+        if (!existsSync(pp)) continue
+        try {
+          const data = JSON.parse(readFileSync(pp, 'utf8'))
+          if (data.noWorktree) return true
+        } catch { /* skip */ }
+      }
+    } catch { /* skip */ }
+  }
+
+  return false
+}
+
+/**
+ * 判断路径是否在 worktree 内
+ * @param {string} filePath - 绝对路径
+ * @returns {boolean}
+ */
+function isInsideWorktree(filePath) {
+  return filePath.includes(WORKTREE_SEGMENT)
+}
+
+/**
+ * 文件白名单：文档类/配置类始终放行
+ * @param {string} filePath - 绝对路径
+ * @returns {boolean}
+ */
+function matchFileWhitelist(filePath) {
+  // 路径以 .sillyspec/ 开头
+  const parts = filePath.split(path.sep)
+  for (let i = 0; i < parts.length; i++) {
+    if (parts[i] === '.sillyspec') return true
+  }
+
+  // 路径在 .git/ 下
+  for (let i = 0; i < parts.length - 1; i++) {
+    if (parts[i] === '.git') return true
+  }
+
+  // 扩展名
+  const ext = path.extname(filePath)
+  if (FILE_WHITELIST_EXTS.includes(ext)) return true
+
+  // 文件名
+  const base = path.basename(filePath)
+  if (FILE_WHITELIST_NAMES.includes(base)) return true
+
+  return false
+}
+
+/**
+ * 读取 local.yaml 中的扩展白名单配置（如果存在）
+ * @param {string} cwd
+ * @returns {{ fileWhitelist?: string[], readonlyCommands?: string[] }}
+ */
+function loadLocalConfig(cwd) {
+  const candidates = [
+    path.join(cwd, 'local.yaml'),
+    path.join(cwd, 'local.yml'),
+  ]
+  for (const p of candidates) {
+    if (!existsSync(p)) continue
+    try {
+      // 简单 YAML 解析（只处理顶层键值对和简单数组）
+      const content = readFileSync(p, 'utf8')
+      return parseSimpleYaml(content)
+    } catch {
+      return {}
+    }
+  }
+  return {}
+}
+
+/**
+ * 简易 YAML 解析，只处理顶层简单结构
+ */
+function parseSimpleYaml(content) {
+  const result = {}
+  let currentKey = null
+  let inArray = false
+
+  for (const line of content.split('\n')) {
+    const trimmed = line.trim()
+    if (!trimmed || trimmed.startsWith('#')) continue
+
+    // 顶层键
+    const topLevelMatch = trimmed.match(/^(\S[\S]*)\s*:\s*(.*)$/)
+    if (topLevelMatch && !trimmed.startsWith(' ')) {
+      const key = topLevelMatch[1]
+      const val = topLevelMatch[2].trim()
+      currentKey = key
+
+      if (val) {
+        // key: value (单行)
+        result[key] = val
+        inArray = false
+      } else {
+        // key: (多行值开始)
+        result[key] = []
+        inArray = true
+      }
+      continue
+    }
+
+    // 数组项
+    if (inArray && currentKey && trimmed.startsWith('- ')) {
+      const item = trimmed.slice(2).trim()
+      if (Array.isArray(result[currentKey])) {
+        result[currentKey].push(item)
+      }
+      continue
+    }
+
+    // 非数组行结束数组模式
+    if (inArray && !trimmed.startsWith('- ') && !trimmed.startsWith('#')) {
+      inArray = false
+    }
+  }
+
+  return result
+}
+
+/**
+ * 提取命令中第一个可执行命令名
+ * @param {string} command
+ * @returns {string}
+ */
+function extractCommandName(command) {
+  const trimmed = command.trim()
+  if (!trimmed) return ''
+  return trimmed.split(/\s+/)[0]
+}
+
+/**
+ * 判断单个命令片段是否匹配只读白名单
+ * @param {string} cmd - 单个命令片段（不含管道/链式操作符）
+ * @param {string[]} extraReadonlyCommands - local.yaml 扩展的只读命令
+ * @returns {boolean}
+ */
+function isSingleCommandReadonly(cmd, extraReadonlyCommands = []) {
+  const trimmed = cmd.trim()
+  if (!trimmed) return true // 空片段放行
+
+  const parts = trimmed.split(/\s+/)
+  const cmdName = parts[0]
+
+  // 纯命令名匹配
+  if (READONLY_COMMANDS.has(cmdName)) {
+    // node/npm/npx 需要进一步检查子命令
+    if (cmdName === 'node' || cmdName === 'npm' || cmdName === 'npx') {
+      const rest = parts.slice(1).join(' ')
+      return rest.includes('--version') || rest.includes('-v') && parts.length <= 3 || rest === 'run test' || rest.startsWith('test')
+    }
+    return true
+  }
+
+  // local.yaml 扩展
+  if (extraReadonlyCommands.includes(cmdName)) return true
+
+  // git 只读子命令
+  if (cmdName === 'git') {
+    const sub = parts[1] || ''
+    if (READONLY_GIT_SUBS.has(sub)) return true
+    // git stash list
+    if (sub === 'stash' && (parts[2] === 'list' || parts.length === 2)) return true
+    return false
+  }
+
+  // sillyspec worktree 命令
+  if (cmdName === 'sillyspec') {
+    const sub = parts[1] || ''
+    if (sub === 'worktree') return true
+    return false
+  }
+
+  return false
+}
+
+/**
+ * 判断单个命令片段是否匹配危险黑名单
+ * @param {string} cmd - 单个命令片段
+ * @returns {boolean}
+ */
+function isSingleCommandDangerous(cmd) {
+  const trimmed = cmd.trim().toLowerCase()
+
+  for (const prefix of DANGER_PREFIXES) {
+    if (trimmed.startsWith(prefix)) return true
+  }
+
+  const parts = trimmed.split(/\s+/)
+  const cmdName = parts[0]
+
+  if (cmdName === 'git') {
+    const sub = parts[1] || ''
+    if (DANGER_GIT_SUBS.has(sub)) return true
+    // git stash drop/clear/pop
+    if (sub === 'stash' && DANGER_STASH_ACTIONS.has(parts[2] || '')) return true
+  }
+
+  // rm（不限于 -rf）
+  if (cmdName === 'rm') return true
+
+  return false
+}
+
+/**
+ * 将命令按管道/链式操作符拆分为多个片段
+ * @param {string} command
+ * @returns {string[]}
+ */
+function splitCommandParts(command) {
+  // 按管道和链式操作符拆分
+  return command.split(/(?:\|\|&&|&&|\|)/g).map(s => s.trim()).filter(Boolean)
+}
+
+/**
+ * 判断命令是否匹配只读白名单（含管道/链式检查）
+ * @param {string} command
+ * @param {string[]} extraReadonlyCommands
+ * @returns {boolean}
+ */
+function matchReadonlyWhitelist(command, extraReadonlyCommands = []) {
+  const parts = splitCommandParts(command)
+  return parts.every(p => isSingleCommandReadonly(p, extraReadonlyCommands))
+}
+
+/**
+ * 判断命令是否匹配危险黑名单（含管道/链式检查）
+ * @param {string} command
+ * @returns {boolean}
+ */
+function matchDangerBlacklist(command) {
+  const parts = splitCommandParts(command)
+  return parts.some(p => isSingleCommandDangerous(p))
+}
+
+// ── 公共接口 ──
+
+/**
+ * 判断文件写入是否应被拦截
+ *
+ * 降级策略（无 worktree = 更严格）:
+ * - noWorktree 模式下，execute/quick 阶段不允许源码写入（没有隔离环境）
+ * - 除非同时设置 SILLYSPEC_DISABLE_HOOKS=1
+ *
+ * @param {string} filePath - 目标文件绝对路径
+ * @param {string} cwd - 当前工作目录
+ * @returns {{ blocked: boolean, reason?: string }}
+ */
+export function shouldBlockWrite(filePath, cwd) {
+  if (!filePath) return { blocked: true, reason: 'no file path' }
+
+  const absPath = path.isAbsolute(filePath) ? filePath : path.resolve(cwd || process.cwd(), filePath)
+
+  // 1. 文件门禁：文档类/配置类始终放行
+  if (matchFileWhitelist(absPath)) return { blocked: false }
+
+  // 2. 阶段门禁
+  const effectiveCwd = cwd || process.cwd()
+  const gateStatus = readGateStatus(effectiveCwd)
+  if (!gateStatus || !ALLOWED_STAGES.includes(gateStatus.stage)) {
+    const stage = gateStatus?.stage || '(none)'
+    return {
+      blocked: true,
+      reason: [
+        `当前阶段 "${stage}" 不允许修改源码。`,
+        `源码修改只能在 execute 或 quick 阶段进行。`,
+        '请先完成文档规划流程：',
+        '  - 小改动：运行 sillyspec run quick',
+        '  - 大改动：运行 sillyspec run brainstorm → plan → execute',
+        '  - 或使用 sillyspec run auto 连续推进全流程',
+      ].join('\n')
+    }
+  }
+
+  // 3. 位置门禁
+  if (isInsideWorktree(absPath)) return { blocked: false }
+
+  // noWorktree 模式：无隔离环境，禁止源码写入（降级到更严格）
+  if (isNoWorktreeMode(effectiveCwd)) {
+    return {
+      blocked: true,
+      reason: [
+        '当前处于 --no-worktree 降级模式，不允许源码写入。',
+        '如需修改源码，请移除 --no-worktree 标志重新执行。',
+        '紧急情况可设置 SILLYSPEC_DISABLE_HOOKS=1 绕过限制。',
+      ].join('\n')
+    }
+  }
+
+  return {
+    blocked: true,
+    reason: [
+      '源码修改只能在 worktree 隔离环境中进行。',
+      'execute/quick 阶段会自动创建 worktree。',
+      '如果你正在 execute 阶段，请确认 worktree 已创建：sillyspec worktree list',
+    ].join('\n')
+  }
+}
+
+/**
+ * 判断 Bash 命令是否应被拦截
+ * @param {string} command - Bash 命令字符串
+ * @param {string} cwd - 当前工作目录
+ * @returns {{ blocked: boolean, reason?: string }}
+ */
+export function shouldBlockBash(command, cwd) {
+  if (!command || !command.trim()) return { blocked: false }
+
+  const effectiveCwd = cwd || process.cwd()
+
+  // cwd 在 worktree 内 → 全部放行
+  if (isInsideWorktree(effectiveCwd)) return { blocked: false }
+
+  // 阶段门禁
+  const gateStatus = readGateStatus(effectiveCwd)
+  const stageOk = gateStatus && ALLOWED_STAGES.includes(gateStatus.stage)
+
+  if (!stageOk) {
+    // 非 execute/quick 阶段，只允许只读白名单
+    const localConfig = loadLocalConfig(effectiveCwd)
+    const extraReadonly = localConfig.worktreeHook?.readonlyCommands || localConfig['worktree-hook']?.readonlyCommands || []
+    if (matchReadonlyWhitelist(command, extraReadonly)) return { blocked: false }
+    const stage = gateStatus?.stage || '(none)'
+    return {
+      blocked: true,
+      reason: [
+        `当前阶段 "${stage}" 不允许执行此命令。`,
+        '源码修改只能在 execute 或 quick 阶段进行。',
+        '请先完成文档规划流程：',
+        '  - 小改动：运行 sillyspec run quick',
+        '  - 大改动：运行 sillyspec run brainstorm → plan → execute',
+      ].join('\n')
+    }
+  }
+
+  // execute/quick 阶段 + 主工作区
+  const localConfig = loadLocalConfig(effectiveCwd)
+  const extraReadonly = localConfig.worktreeHook?.readonlyCommands || localConfig['worktree-hook']?.readonlyCommands || []
+
+  // 危险黑名单
+  if (matchDangerBlacklist(command)) {
+    return { blocked: true, reason: `dangerous command blocked: ${command.trim()}` }
+  }
+
+  // 只读白名单放行
+  if (matchReadonlyWhitelist(command, extraReadonly)) return { blocked: false }
+
+  // 不确定 → 放行
+  return { blocked: false }
+}
+
+/**
+ * 判断工具调用是否应被拦截
+ * @param {{
+ *   tool: 'Write' | 'Edit' | 'MultiEdit' | 'Bash',
+ *   filePath?: string,
+ *   filePaths?: string[],
+ *   command?: string,
+ *   cwd?: string
+ * }} opts
+ * @param {{ cwd?: string }} ctx
+ * @returns {{ blocked: boolean, reason?: string }}
+ */
+export function shouldBlock(opts, ctx = {}) {
+  // 逃生开关
+  if (process.env.SILLYSPEC_DISABLE_HOOKS === '1') return { blocked: false }
+
+  const cwd = opts.cwd || ctx.cwd || process.cwd()
+
+  switch (opts.tool) {
+    case 'Write':
+    case 'Edit': {
+      const fp = opts.filePath
+      if (!fp) return { blocked: true, reason: 'no file path' }
+      const absPath = path.isAbsolute(fp) ? fp : path.resolve(cwd, fp)
+      return shouldBlockWrite(absPath, cwd)
+    }
+    case 'MultiEdit': {
+      const filePaths = opts.filePaths
+      if (!filePaths || filePaths.length === 0) return { blocked: true, reason: 'no file paths' }
+      for (const fp of filePaths) {
+        const absPath = path.isAbsolute(fp) ? fp : path.resolve(cwd, fp)
+        const result = shouldBlockWrite(absPath, cwd)
+        if (result.blocked) return result
+      }
+      return { blocked: false }
+    }
+    case 'Bash': {
+      return shouldBlockBash(opts.command || '', cwd)
+    }
+    default:
+      return { blocked: false }
+  }
+}

package/src/index.js

@@ -257,6 +257,121 @@ async function main() {
       console.log('按 Ctrl+C 停止服务器');
       break;
     }
+    case 'worktree': {
+      const { WorktreeManager } = await import('./worktree.js');
+      const wtSubCmd = filteredArgs[1];
+      const wtName = filteredArgs[2];
+      const wm = new WorktreeManager({ cwd: dir });
+
+      if (!wtSubCmd || wtSubCmd === 'help' || wtSubCmd === '--help' || wtSubCmd === '-h') {
+        console.log(`
+SillySpec worktree — git worktree 隔离管理
+
+用法:
+  sillyspec worktree create <change-name> [--base <branch>]   创建隔离 worktree
+  sillyspec worktree apply <change-name> [--check-only]        校验并应用变更到主工作区
+  sillyspec worktree list                                      列出所有活跃 worktree
+  sillyspec worktree cleanup <change-name>                      强制清理 worktree
+
+选项:
+  --base <branch>       create: 指定基础分支（默认当前 HEAD）
+  --check-only          apply: 只输出检查结果，不实际 apply
+`);
+        break;
+      }
+
+      switch (wtSubCmd) {
+        case 'create': {
+          if (!wtName) {
+            console.error('❌ 用法: sillyspec worktree create <change-name> [--base <branch>]');
+            process.exit(1);
+          }
+          const baseIdx = args.indexOf('--base');
+          const base = baseIdx >= 0 && args[baseIdx + 1] ? args[baseIdx + 1] : undefined;
+          try {
+            const info = wm.create(wtName, { base });
+            console.log(`✅ worktree 已创建`);
+            console.log(`   分支: ${info.branch}`);
+            console.log(`   路径: ${info.worktreePath}`);
+            console.log(`   基准: ${info.baseHash.slice(0, 8)}`);
+          } catch (e) {
+            console.error(`❌ ${e.message}`);
+            process.exit(1);
+          }
+          break;
+        }
+        case 'apply': {
+          if (!wtName) {
+            console.error('❌ 用法: sillyspec worktree apply <change-name> [--check-only]');
+            process.exit(1);
+          }
+          const checkOnly = args.includes('--check-only');
+          const { applyWorktree } = await import('./worktree-apply.js');
+          const result = applyWorktree(wtName, { cwd: dir, checkOnly });
+
+          if (result.errors.length > 0) {
+            console.error(`❌ 校验失败:`);
+            for (const err of result.errors) {
+              console.error(`   ${err}`);
+            }
+            process.exit(1);
+          }
+
+          if (result.changedFiles.length === 0) {
+            console.log('📭 无变更需要应用');
+            break;
+          }
+
+          if (checkOnly) {
+            console.log(`✅ 检查通过 (${result.changedFiles.length} 个文件):`);
+            for (const f of result.changedFiles) {
+              console.log(`   ${f}`);
+            }
+          } else {
+            console.log(`✅ 已应用 ${result.changedFiles.length} 个文件变更`);
+          }
+          break;
+        }
+        case 'list': {
+          const items = wm.list();
+          if (items.length === 0) {
+            console.log('📭 无活跃 worktree');
+            break;
+          }
+          // 计算列宽
+          const maxName = Math.max('Change Name'.length, ...items.map(i => i.changeName.length));
+          const maxBranch = Math.max('Branch'.length, ...items.map(i => i.branch.length));
+          const header = `  ${'Change Name'.padEnd(maxName)}  ${'Branch'.padEnd(maxBranch)}  Created`;
+          const sep = `  ${'─'.repeat(maxName)}  ${'─'.repeat(maxBranch)}  ${'─'.repeat(19)}`;
+          console.log(header);
+          console.log(sep);
+          for (const item of items) {
+            const created = item.createdAt ? item.createdAt.replace('T', ' ').replace('Z', '').slice(0, 19) : '-';
+            console.log(`  ${item.changeName.padEnd(maxName)}  ${item.branch.padEnd(maxBranch)}  ${created}`);
+          }
+          break;
+        }
+        case 'cleanup': {
+          if (!wtName) {
+            console.error('❌ 用法: sillyspec worktree cleanup <change-name>');
+            process.exit(1);
+          }
+          try {
+            wm.cleanup(wtName);
+            console.log(`✅ worktree 已清理: ${wtName}`);
+          } catch (e) {
+            console.error(`❌ ${e.message}`);
+            process.exit(1);
+          }
+          break;
+        }
+        default:
+          console.error(`❌ 未知子命令: worktree ${wtSubCmd}`);
+          console.log('   运行 sillyspec worktree --help 查看帮助');
+          process.exit(1);
+      }
+      break;
+    }
     default:
       console.error(`❌ 未知命令: ${command}`);
       printUsage();

package/src/progress.js

@@ -11,7 +11,7 @@
  */
 
 import { existsSync, mkdirSync, readFileSync, writeFileSync, renameSync, copyFileSync, unlinkSync, readdirSync } from 'fs';
-import { join, basename } from 'path';
+import { join, basename, resolve } from 'path';
 
 const RUNTIME_DIR = '.sillyspec/.runtime';
 const CHANGES_DIR = '.sillyspec/changes';
@@ -199,6 +199,7 @@ export class ProgressManager {
       const tmpPath = progressPath + '.tmp';
       writeFileSync(tmpPath, JSON.stringify(data, null, 2) + '\n');
       renameSync(tmpPath, progressPath);
+      this._updateGateStatus(cwd);
       return;
     }
 
@@ -207,6 +208,7 @@ export class ProgressManager {
     const tmpPath = progressPath + '.tmp';
     writeFileSync(tmpPath, JSON.stringify(data, null, 2) + '\n');
     renameSync(tmpPath, progressPath);
+    this._updateGateStatus(cwd);
   }
 
   _backup(cwd, data) {
@@ -693,6 +695,60 @@ export class ProgressManager {
     return `📊 批量进度: ${bar} ${completed}/${total}${suffix}`;
   }
 
+  /**
+   * 更新 gate-status.json，供 worktree-guard hook 读取
+   * 扫描所有活跃变更的 currentStage，任一为 execute/quick 则 stage 设为该值
+   */
+  _updateGateStatus(cwd) {
+    const changes = this.listChanges(cwd);
+    if (changes.length === 0) {
+      // 无活跃变更，删除 gate-status（如果存在）
+      const gatePath = this._runtimePath(cwd, 'gate-status.json');
+      if (existsSync(gatePath)) {
+        try { unlinkSync(gatePath); } catch {}
+      }
+      return;
+    }
+
+    let gateStage = null;
+    let hasNoWorktree = false;
+    const activeChanges = [];
+
+    for (const cn of changes) {
+      const data = this.read(cwd, cn);
+      if (!data || !data.currentStage) continue;
+      const stage = data.currentStage;
+      if (['execute', 'quick'].includes(stage)) {
+        // 优先取 execute，其次 quick
+        if (gateStage !== 'execute' || stage === 'execute') {
+          gateStage = stage;
+        }
+        activeChanges.push(cn);
+        if (data.noWorktree) hasNoWorktree = true;
+      }
+    }
+
+    const gatePath = this._runtimePath(cwd, 'gate-status.json');
+
+    if (gateStage) {
+      this._ensureRuntimeDir(cwd);
+      const gateData = {
+        stage: gateStage,
+        changes: activeChanges,
+        updatedAt: new Date().toISOString(),
+        ...(hasNoWorktree ? { noWorktree: true } : {}),
+      };
+      const tmpPath = gatePath + '.tmp';
+      writeFileSync(tmpPath, JSON.stringify(gateData, null, 2) + '\n');
+      renameSync(tmpPath, gatePath);
+    } else {
+      // 无 execute/quick 阶段，删除 gate-status
+      if (existsSync(gatePath)) {
+        try { unlinkSync(gatePath); } catch {}
+      }
+    }
+  }
+
   _ensureGitignore(cwd) {
     const gitignorePath = join(cwd, '.gitignore');
     const rule = '.sillyspec/.runtime/';