@gong-ym/ai-spec-auto 0.2.3

package/bin/runtime-launcher.js

@@ -0,0 +1,116 @@
+const fs = require('fs');
+const path = require('path');
+
+const runtimeBootstrap = require('./runtime-bootstrap');
+const runtimeEmbedded = require('./runtime-embedded');
+
+function getLauncherPaths(env = process.env) {
+  const { aiSpecHome } = runtimeBootstrap.__test__.getRuntimePaths(env);
+  return {
+    aiSpecHome,
+    binDir: path.join(aiSpecHome, 'bin'),
+    libDir: path.join(aiSpecHome, 'lib'),
+    launcherFile: path.join(aiSpecHome, 'bin', 'ai-spec-auto'),
+    launcherCmdFile: path.join(aiSpecHome, 'bin', 'ai-spec-auto.cmd'),
+    launcherBootstrapFile: path.join(aiSpecHome, 'lib', 'runtime-bootstrap.js'),
+  };
+}
+
+function renderLauncherScript() {
+  return `#!/usr/bin/env node
+const path = require('path');
+const runtimeBootstrap = require(path.join(__dirname, '..', 'lib', 'runtime-bootstrap.js'));
+
+(async () => {
+  try {
+    const result = await runtimeBootstrap.maybeHandOffToRuntime({
+      pkgRoot: path.join(__dirname, '..'),
+      args: process.argv.slice(2),
+      env: process.env,
+      cwd: process.cwd(),
+      stdio: 'inherit',
+      manageAllCommands: true,
+    });
+    if (result.handedOff) {
+      process.exit(result.status);
+    }
+    throw new Error('未找到可用的 ai-spec-auto runtime，请先检查用户级缓存与 registry 配置。');
+  } catch (error) {
+    if (error && error.message) {
+      console.error(error.message);
+    }
+    process.exit(error && Number.isInteger(error.status) ? error.status : 1);
+  }
+})();
+`;
+}
+
+function renderLauncherCmd() {
+  return `@echo off
+node "%~dp0ai-spec-auto" %*
+`;
+}
+
+function ensureExecutable(filePath) {
+  try {
+    fs.chmodSync(filePath, 0o755);
+  } catch (_error) {
+    // ignore on unsupported platforms
+  }
+}
+
+function ensureGlobalLauncher({
+  pkgRoot,
+  env = process.env,
+  now = Date.now(),
+} = {}) {
+  const launcherPaths = getLauncherPaths(env);
+  fs.mkdirSync(launcherPaths.binDir, { recursive: true });
+  fs.mkdirSync(launcherPaths.libDir, { recursive: true });
+
+  const sourceBootstrap = path.join(pkgRoot, 'bin', 'runtime-bootstrap.js');
+  fs.copyFileSync(sourceBootstrap, launcherPaths.launcherBootstrapFile);
+  const sourceFallback = path.join(pkgRoot, 'bin', 'runtime-fallback.js');
+  if (fs.existsSync(sourceFallback)) {
+    fs.copyFileSync(sourceFallback, path.join(launcherPaths.libDir, 'runtime-fallback.js'));
+  }
+  const sourceEmbedded = path.join(pkgRoot, 'bin', 'runtime-embedded.js');
+  if (fs.existsSync(sourceEmbedded)) {
+    fs.copyFileSync(sourceEmbedded, path.join(launcherPaths.libDir, 'runtime-embedded.js'));
+  }
+  fs.writeFileSync(launcherPaths.launcherFile, renderLauncherScript(), 'utf8');
+  ensureExecutable(launcherPaths.launcherFile);
+  fs.writeFileSync(launcherPaths.launcherCmdFile, renderLauncherCmd(), 'utf8');
+  runtimeEmbedded.syncEmbeddedRuntime({
+    pkgRoot,
+    env,
+  });
+
+  const packageJsonPath = path.join(pkgRoot, 'package.json');
+  const packageJson = fs.existsSync(packageJsonPath)
+    ? JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'))
+    : {};
+  const installSpec = env.ENGINEERED_SPEC_FORCE_LOCAL_CLI
+    ? pkgRoot
+    : env.AI_SPEC_RUNTIME_INSTALL_SPEC || (packageJson.name ? `${packageJson.name}@latest` : pkgRoot);
+  const registry = env.AI_SPEC_RUNTIME_REGISTRY || packageJson.publishConfig?.registry || '';
+  const packageName = packageJson.name || '';
+
+  runtimeBootstrap.__test__.writeBootstrapConfig(env, {
+    install_spec: installSpec,
+    registry,
+    package_name: packageName,
+    updated_at: new Date(now).toISOString(),
+  });
+
+  return launcherPaths;
+}
+
+module.exports = {
+  ensureGlobalLauncher,
+  __test__: {
+    getLauncherPaths,
+    renderLauncherScript,
+    renderLauncherCmd,
+  },
+};

package/bin/runtime-paths.js

@@ -0,0 +1,177 @@
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const crypto = require('crypto');
+
+function buildEntry(targetDir, relPath, legacyRelPath = null) {
+  const legacyRelPaths = Array.isArray(legacyRelPath)
+    ? legacyRelPath.filter(Boolean)
+    : [legacyRelPath].filter(Boolean);
+  const isAbsolute = path.isAbsolute(relPath);
+  return {
+    relPath,
+    path: isAbsolute ? relPath : path.join(targetDir, relPath),
+    legacyRelPath: legacyRelPaths[0] || null,
+    legacyPath: legacyRelPaths[0] ? path.join(targetDir, legacyRelPaths[0]) : null,
+    legacyRelPaths,
+    legacyPaths: legacyRelPaths.map((item) => path.join(targetDir, item)),
+  };
+}
+
+function buildHistoryEntry(targetDir, relPathSegments, legacyRelPath = null) {
+  const explicitRoot = process.env.AI_SPEC_HISTORY_DIR || process.env.ENGINEERED_SPEC_HISTORY_DIR || null;
+  const targetHash = crypto.createHash('sha1').update(path.resolve(targetDir)).digest('hex').slice(0, 12);
+  const historyRoot = explicitRoot
+    ? path.resolve(explicitRoot)
+    : path.join(os.homedir(), '.cache', 'ai-spec-auto', 'history', targetHash);
+  const absolutePath = path.join(historyRoot, ...relPathSegments);
+  return buildEntry(targetDir, absolutePath, legacyRelPath);
+}
+
+function resolveRuntimePaths(targetDir) {
+  return {
+    aiSpecDir: buildEntry(targetDir, path.join('.ai-spec')),
+    internalDir: buildEntry(targetDir, path.join('.ai-spec', 'internal')),
+    currentRun: buildEntry(targetDir, path.join('.ai-spec', 'current-run.json')),
+    checkpointsDir: buildEntry(targetDir, path.join('.ai-spec', 'checkpoints')),
+    repoMap: buildEntry(targetDir, path.join('.ai-spec', 'repo-map.json')),
+    runsDir: buildHistoryEntry(
+      targetDir,
+      ['runs'],
+      [path.join('.ai-spec', 'internal', 'history', 'runs'), path.join('.ai-spec', 'runs')],
+    ),
+    tmpDir: buildEntry(targetDir, path.join('.ai-spec', 'internal', 'tmp'), path.join('.ai-spec', 'tmp')),
+    tmpTaskOrchestratorTurn: buildEntry(
+      targetDir,
+      path.join('.ai-spec', 'internal', 'tmp', 'task-orchestrator-turn.json'),
+      [
+        path.join('.ai-spec', 'internal', 'tmp', 'task-orchestrator-reply.md'),
+        path.join('.ai-spec', 'tmp', 'task-orchestrator-reply.md'),
+      ],
+    ),
+    tmpTaskOrchestratorReply: buildEntry(
+      targetDir,
+      path.join('.ai-spec', 'internal', 'tmp', 'task-orchestrator-reply.md'),
+      path.join('.ai-spec', 'tmp', 'task-orchestrator-reply.md'),
+    ),
+    tmpCurrentDispatch: buildEntry(
+      targetDir,
+      path.join('.ai-spec', 'internal', 'tmp', 'current-dispatch.json'),
+      path.join('.ai-spec', 'tmp', 'current-dispatch.json'),
+    ),
+    tmpCurrentExecution: buildEntry(
+      targetDir,
+      path.join('.ai-spec', 'internal', 'tmp', 'current-execution.json'),
+      path.join('.ai-spec', 'tmp', 'current-execution.json'),
+    ),
+    tmpCurrentRuntimeAction: buildEntry(
+      targetDir,
+      path.join('.ai-spec', 'internal', 'tmp', 'current-runtime-action.json'),
+      path.join('.ai-spec', 'tmp', 'current-runtime-action.json'),
+    ),
+    currentDispatch: buildEntry(
+      targetDir,
+      path.join('.ai-spec', 'internal', 'current-dispatch.json'),
+      path.join('.ai-spec', 'current-dispatch.json'),
+    ),
+    dispatchesDir: buildHistoryEntry(
+      targetDir,
+      ['dispatches'],
+      [
+        path.join('.ai-spec', 'internal', 'history', 'dispatches'),
+        path.join('.ai-spec', 'internal', 'dispatches'),
+        path.join('.ai-spec', 'dispatches'),
+      ],
+    ),
+    currentExecutionJson: buildEntry(
+      targetDir,
+      path.join('.ai-spec', 'internal', 'current-execution.json'),
+      path.join('.ai-spec', 'current-execution.json'),
+    ),
+    currentExecutionMd: buildEntry(
+      targetDir,
+      path.join('.ai-spec', 'internal', 'current-execution.md'),
+      path.join('.ai-spec', 'current-execution.md'),
+    ),
+    executionsDir: buildHistoryEntry(
+      targetDir,
+      ['executions'],
+      [
+        path.join('.ai-spec', 'internal', 'history', 'executions'),
+        path.join('.ai-spec', 'internal', 'executions'),
+        path.join('.ai-spec', 'executions'),
+      ],
+    ),
+    currentRuntimeActionJson: buildEntry(
+      targetDir,
+      path.join('.ai-spec', 'internal', 'current-runtime-action.json'),
+      path.join('.ai-spec', 'current-runtime-action.json'),
+    ),
+    currentRuntimeActionMd: buildEntry(
+      targetDir,
+      path.join('.ai-spec', 'internal', 'current-runtime-action.md'),
+      path.join('.ai-spec', 'current-runtime-action.md'),
+    ),
+    runtimeActionsDir: buildHistoryEntry(
+      targetDir,
+      ['runtime-actions'],
+      [
+        path.join('.ai-spec', 'internal', 'history', 'runtime-actions'),
+        path.join('.ai-spec', 'internal', 'runtime-actions'),
+        path.join('.ai-spec', 'runtime-actions'),
+      ],
+    ),
+    runnerConsumedDir: buildHistoryEntry(
+      targetDir,
+      ['runner', 'consumed'],
+      path.join('.ai-spec', 'runner', 'consumed'),
+    ),
+  };
+}
+
+function getExistingPath(entry) {
+  if (fs.existsSync(entry.path)) {
+    return entry.path;
+  }
+  for (const candidate of entry.legacyPaths || []) {
+    if (fs.existsSync(candidate)) {
+      return candidate;
+    }
+  }
+  return entry.path;
+}
+
+function getExistingRelPath(entry) {
+  if (fs.existsSync(entry.path)) {
+    return entry.relPath;
+  }
+  const legacyRelPaths = entry.legacyRelPaths || [];
+  const legacyPaths = entry.legacyPaths || [];
+  for (let index = 0; index < legacyPaths.length; index += 1) {
+    if (fs.existsSync(legacyPaths[index])) {
+      return legacyRelPaths[index];
+    }
+  }
+  return entry.relPath;
+}
+
+function getCandidatePaths(entry) {
+  return [entry.path, ...(entry.legacyPaths || [])].filter(Boolean);
+}
+
+function shouldPersistHistory() {
+  return process.env.AI_SPEC_PERSIST_HISTORY === '1' || process.env.ENGINEERED_SPEC_DEBUG_HISTORY === '1';
+}
+
+function shouldPersistCheckpoints() {
+  return process.env.AI_SPEC_PERSIST_CHECKPOINTS === '1' || process.env.ENGINEERED_SPEC_DEBUG_CHECKPOINTS === '1';
+}
+
+module.exports = {
+  resolveRuntimePaths,
+  getExistingPath,
+  getExistingRelPath,
+  getCandidatePaths,
+  shouldPersistHistory,
+  shouldPersistCheckpoints,
+};

package/bin/runtime-registry.js

@@ -0,0 +1,289 @@
+const fs = require('fs');
+const path = require('path');
+const {
+  resolveProfileId,
+} = require('./profile-registry');
+
+const PACKAGE_ROOT = path.join(__dirname, '..');
+const REGISTRY_CACHE = new Map();
+
+function readJsonFile(filePath, label) {
+  const raw = fs.readFileSync(filePath, 'utf8');
+  try {
+    return JSON.parse(raw);
+  } catch (error) {
+    throw new Error(`${label} is not valid JSON: ${filePath}`);
+  }
+}
+
+function uniqueWorkspaceRoots(targetDir) {
+  const roots = [PACKAGE_ROOT, path.resolve(targetDir || '.')];
+  return [...new Set(roots)];
+}
+
+function cloneValue(value) {
+  return JSON.parse(JSON.stringify(value));
+}
+
+function buildRegistrySourceDescriptors(targetDir, fileName) {
+  return uniqueWorkspaceRoots(targetDir).map((root) => {
+    const filePath = path.join(root, '.agents', 'registry', fileName);
+    if (!fs.existsSync(filePath)) {
+      return {
+        root,
+        filePath,
+        exists: false,
+      };
+    }
+
+    const stat = fs.statSync(filePath);
+    return {
+      root,
+      filePath,
+      exists: true,
+      mtimeMs: stat.mtimeMs,
+      size: stat.size,
+    };
+  });
+}
+
+function buildRegistryCacheKey(targetDir, fileName, objectKey) {
+  return JSON.stringify({
+    sources: buildRegistrySourceDescriptors(targetDir, fileName),
+    fileName,
+    objectKey,
+  });
+}
+
+function mergeNamedEntries(baseEntries, overrideEntries) {
+  const merged = {
+    ...(baseEntries || {}),
+  };
+
+  for (const [id, entry] of Object.entries(overrideEntries || {})) {
+    const nextEntry = {
+      ...(merged[id] || {}),
+    };
+    if (entry && typeof entry === 'object' && !Array.isArray(entry)) {
+      if (Object.prototype.hasOwnProperty.call(entry, 'source')) {
+        delete nextEntry.sourceByProfile;
+      }
+      if (Object.prototype.hasOwnProperty.call(entry, 'sourceByProfile')) {
+        delete nextEntry.source;
+      }
+      if (
+        Object.prototype.hasOwnProperty.call(entry, 'rule_ids') &&
+        !Object.prototype.hasOwnProperty.call(entry, 'rule_ids_by_profile')
+      ) {
+        delete nextEntry.rule_ids_by_profile;
+      }
+      if (
+        (Object.prototype.hasOwnProperty.call(entry, 'skill_priority') ||
+          Object.prototype.hasOwnProperty.call(entry, 'preferred_skills')) &&
+        !Object.prototype.hasOwnProperty.call(entry, 'skill_priority_by_profile') &&
+        !Object.prototype.hasOwnProperty.call(entry, 'preferred_skills_by_profile')
+      ) {
+        delete nextEntry.skill_priority_by_profile;
+        delete nextEntry.preferred_skills_by_profile;
+      }
+    }
+    merged[id] = {
+      ...nextEntry,
+      ...(entry || {}),
+    };
+  }
+
+  return merged;
+}
+
+function loadRegistryFile(targetDir, fileName, objectKey) {
+  const cacheKey = buildRegistryCacheKey(targetDir, fileName, objectKey);
+  if (REGISTRY_CACHE.has(cacheKey)) {
+    return cloneValue(REGISTRY_CACHE.get(cacheKey));
+  }
+
+  const roots = uniqueWorkspaceRoots(targetDir);
+  const loaded = [];
+
+  for (const root of roots) {
+    const filePath = path.join(root, '.agents', 'registry', fileName);
+    if (!fs.existsSync(filePath)) {
+      continue;
+    }
+    loaded.push({
+      root,
+      filePath,
+      data: readJsonFile(filePath, fileName),
+    });
+  }
+
+  if (loaded.length === 0) {
+    const emptyRegistry = {
+      version: 1,
+      support_files: [],
+      [objectKey]: {},
+      _sources: [],
+    };
+    REGISTRY_CACHE.set(cacheKey, emptyRegistry);
+    return cloneValue(emptyRegistry);
+  }
+
+  const merged = {
+    version: typeof loaded[0].data.version === 'number' ? loaded[0].data.version : 1,
+    support_files: Array.isArray(loaded[0].data.support_files) ? [...loaded[0].data.support_files] : [],
+    [objectKey]: {},
+    _sources: loaded.map((item) => item.filePath),
+  };
+
+  for (const item of loaded) {
+    if (typeof item.data.version === 'number') {
+      merged.version = item.data.version;
+    }
+    if (Array.isArray(item.data.support_files)) {
+      merged.support_files = [...item.data.support_files];
+    }
+    merged[objectKey] = mergeNamedEntries(merged[objectKey], item.data[objectKey]);
+  }
+
+  REGISTRY_CACHE.set(cacheKey, merged);
+  return cloneValue(merged);
+}
+
+function clearRegistryCache() {
+  REGISTRY_CACHE.clear();
+}
+
+function loadRolesRegistry(targetDir) {
+  return loadRegistryFile(targetDir, 'roles.json', 'roles');
+}
+
+function loadFlowsRegistry(targetDir) {
+  return loadRegistryFile(targetDir, 'flows.json', 'flows');
+}
+
+function loadRulesRegistry(targetDir) {
+  return loadRegistryFile(targetDir, 'rules.json', 'rules');
+}
+
+function loadSkillsRegistry(targetDir) {
+  return loadRegistryFile(targetDir, 'skills.json', 'skills');
+}
+
+function loadProfilesRegistry(targetDir) {
+  return loadRegistryFile(targetDir, 'profiles.json', 'profiles');
+}
+
+function getRoleRuntimeConfig(targetDir, roleId) {
+  if (!roleId) {
+    return null;
+  }
+  const rolesRegistry = loadRolesRegistry(targetDir);
+  return rolesRegistry.roles?.[roleId] || null;
+}
+
+function getFlowRuntimeConfig(targetDir, flowId) {
+  if (!flowId) {
+    return null;
+  }
+  const flowsRegistry = loadFlowsRegistry(targetDir);
+  return flowsRegistry.flows?.[flowId] || null;
+}
+
+function getRuleRuntimeConfig(targetDir, ruleId) {
+  if (!ruleId) {
+    return null;
+  }
+  const rulesRegistry = loadRulesRegistry(targetDir);
+  return rulesRegistry.rules?.[ruleId] || null;
+}
+
+function getSkillRuntimeConfig(targetDir, skillId) {
+  if (!skillId) {
+    return null;
+  }
+  const skillsRegistry = loadSkillsRegistry(targetDir);
+  return skillsRegistry.skills?.[skillId] || null;
+}
+
+function resolveRuntimeProfileId(targetDir, profileId) {
+  if (!profileId) {
+    return null;
+  }
+  return resolveProfileId(loadProfilesRegistry(targetDir), profileId);
+}
+
+function normalizeStringArray(value) {
+  if (!Array.isArray(value)) {
+    return [];
+  }
+  return value
+    .map((item) => (typeof item === 'string' ? item.trim() : ''))
+    .filter(Boolean);
+}
+
+function uniqueList(values) {
+  const out = [];
+  const seen = new Set();
+  for (const value of values) {
+    const trimmed = String(value || '').trim();
+    if (!trimmed || seen.has(trimmed)) continue;
+    seen.add(trimmed);
+    out.push(trimmed);
+  }
+  return out;
+}
+
+function getProfileSpecificArray(entry, projectProfile, key, fallbackKey = null) {
+  if (!entry || typeof entry !== 'object' || !projectProfile) {
+    return [];
+  }
+  const byProfile = entry[key];
+  if (byProfile && typeof byProfile === 'object' && !Array.isArray(byProfile)) {
+    return normalizeStringArray(byProfile[projectProfile]);
+  }
+  if (fallbackKey) {
+    const alt = entry[fallbackKey];
+    if (alt && typeof alt === 'object' && !Array.isArray(alt)) {
+      return normalizeStringArray(alt[projectProfile]);
+    }
+  }
+  return [];
+}
+
+function getRoleRuleIds(targetDir, roleId, projectProfile) {
+  const registryEntry = getRoleRuntimeConfig(targetDir, roleId);
+  return uniqueList([
+    ...normalizeStringArray(registryEntry?.rule_ids),
+    ...getProfileSpecificArray(registryEntry, projectProfile, 'rule_ids_by_profile'),
+  ]);
+}
+
+function getRoleSkillPriority(targetDir, roleId, projectProfile) {
+  const registryEntry = getRoleRuntimeConfig(targetDir, roleId);
+  return uniqueList([
+    ...normalizeStringArray(registryEntry?.skill_priority || registryEntry?.preferred_skills),
+    ...getProfileSpecificArray(
+      registryEntry,
+      projectProfile,
+      'skill_priority_by_profile',
+      'preferred_skills_by_profile',
+    ),
+  ]);
+}
+
+module.exports = {
+  PACKAGE_ROOT,
+  loadProfilesRegistry,
+  loadRulesRegistry,
+  loadSkillsRegistry,
+  loadRolesRegistry,
+  loadFlowsRegistry,
+  getRuleRuntimeConfig,
+  getSkillRuntimeConfig,
+  getRoleRuntimeConfig,
+  getFlowRuntimeConfig,
+  getRoleRuleIds,
+  getRoleSkillPriority,
+  resolveRuntimeProfileId,
+  clearRegistryCache,
+};