code-abyss 2.0.6 → 2.0.8

package/bin/lib/pack-reports.js

@@ -0,0 +1,87 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+function ensureReportsDir(projectRoot) {
+  const dir = path.join(projectRoot, '.code-abyss', 'reports');
+  fs.mkdirSync(dir, { recursive: true });
+  return dir;
+}
+
+function safeStamp(date = new Date()) {
+  return date.toISOString().replace(/[:]/g, '-');
+}
+
+function writeReportArtifact(projectRoot, kind, payload) {
+  const reportsDir = ensureReportsDir(projectRoot);
+  const fileName = `${kind}-${safeStamp()}.json`;
+  const filePath = path.join(reportsDir, fileName);
+  fs.writeFileSync(filePath, `${JSON.stringify(payload, null, 2)}\n`);
+  return filePath;
+}
+
+function listReportArtifacts(projectRoot, kindPrefix = null) {
+  const reportsDir = ensureReportsDir(projectRoot);
+  return fs.readdirSync(reportsDir)
+    .filter((name) => name.endsWith('.json'))
+    .filter((name) => !kindPrefix || name.startsWith(kindPrefix))
+    .map((name) => {
+      const filePath = path.join(reportsDir, name);
+      const stat = fs.statSync(filePath);
+      return {
+        name,
+        path: filePath,
+        mtimeMs: stat.mtimeMs,
+      };
+    })
+    .sort((a, b) => b.mtimeMs - a.mtimeMs);
+}
+
+function readLatestReportArtifact(projectRoot, kindPrefix = null) {
+  const reports = listReportArtifacts(projectRoot, kindPrefix);
+  if (reports.length === 0) return null;
+  const latest = reports[0];
+  return {
+    ...latest,
+    data: JSON.parse(fs.readFileSync(latest.path, 'utf8')),
+  };
+}
+
+function deriveReportKind(name) {
+  return name.replace(/-\d{4}-\d{2}-\d{2}T\d{2}-\d{2}-\d{2}\.\d{3}Z\.json$/, '');
+}
+
+function summarizeReportArtifacts(projectRoot, kindPrefix = null) {
+  const reports = listReportArtifacts(projectRoot, kindPrefix);
+  const seen = new Set();
+  const summary = [];
+
+  reports.forEach((report) => {
+    const kind = deriveReportKind(report.name);
+    if (seen.has(kind)) return;
+    seen.add(kind);
+
+    const data = JSON.parse(fs.readFileSync(report.path, 'utf8'));
+    summary.push({
+      kind,
+      name: report.name,
+      path: report.path,
+      mtimeMs: report.mtimeMs,
+      target: data.target || null,
+      pack: data.pack || null,
+      packReports: data.pack_reports || [],
+      reports: data.reports || [],
+    });
+  });
+
+  return summary;
+}
+
+module.exports = {
+  ensureReportsDir,
+  writeReportArtifact,
+  listReportArtifacts,
+  readLatestReportArtifact,
+  summarizeReportArtifacts,
+};

package/bin/lib/pack-vendor.js

@@ -0,0 +1,82 @@
+'use strict';
+
+const { getPack } = require('./pack-registry');
+const { shared, getVendorProvider } = require('./vendor-providers');
+
+function getPackVendorDir(projectRoot, packName) {
+  return shared.path.join(projectRoot, '.code-abyss', 'vendor', packName);
+}
+
+function ensurePackUpstream(projectRoot, packName) {
+  const pack = getPack(projectRoot, packName);
+  if (!pack.upstream) {
+    throw new Error(`pack ${packName} 未声明 upstream`);
+  }
+  const upstream = {
+    provider: pack.upstream.provider || 'git',
+    ...pack.upstream,
+  };
+  getVendorProvider(upstream.provider, projectRoot).validate(upstream);
+  return upstream;
+}
+
+function syncPackVendor(projectRoot, packName) {
+  const upstream = ensurePackUpstream(projectRoot, packName);
+  const vendorDir = getPackVendorDir(projectRoot, packName);
+  shared.fs.mkdirSync(shared.path.dirname(vendorDir), { recursive: true });
+  const provider = getVendorProvider(upstream.provider, projectRoot);
+  return provider.sync({ projectRoot, upstream, vendorDir, shared, packName });
+}
+
+function removePackVendor(projectRoot, packName) {
+  const vendorDir = getPackVendorDir(projectRoot, packName);
+  if (!shared.fs.existsSync(vendorDir)) {
+    return { pack: packName, removed: false, vendorDir };
+  }
+  shared.fs.rmSync(vendorDir, { recursive: true, force: true });
+  return { pack: packName, removed: true, vendorDir };
+}
+
+function readVendorMetadata(projectRoot, packName) {
+  const vendorDir = getPackVendorDir(projectRoot, packName);
+  const metaPath = shared.path.join(vendorDir, '.code-abyss-vendor.json');
+  if (!shared.fs.existsSync(metaPath)) return null;
+  return JSON.parse(shared.fs.readFileSync(metaPath, 'utf8'));
+}
+
+function getPackVendorStatus(projectRoot, packName) {
+  const upstream = ensurePackUpstream(projectRoot, packName);
+  const vendorDir = getPackVendorDir(projectRoot, packName);
+  const provider = upstream.provider || 'git';
+  const exists = shared.fs.existsSync(vendorDir);
+
+  if (!exists) {
+    return {
+      pack: packName,
+      provider,
+      vendorDir,
+      exists: false,
+      dirty: false,
+      drifted: false,
+      currentCommit: null,
+      targetCommit: upstream.commit || null,
+      sourceExists: false,
+      metadata: null,
+    };
+  }
+
+  const metadata = readVendorMetadata(projectRoot, packName);
+  return getVendorProvider(provider, projectRoot).status({ projectRoot, upstream, vendorDir, shared, packName, metadata });
+}
+
+module.exports = {
+  getPackVendorDir,
+  ensurePackUpstream,
+  syncPackVendor,
+  removePackVendor,
+  readVendorMetadata,
+  getPackVendorStatus,
+  resolveUpstreamPath: shared.resolveUpstreamPath,
+  hashDirectory: shared.hashDirectory,
+  hashFile: shared.hashFile,
+};

package/bin/lib/style-registry.js

@@ -2,16 +2,26 @@
 
 const fs = require('fs');
 const path = require('path');
+const { listTargetNames } = require('./target-registry');
 
-const SUPPORTED_TARGETS = new Set(['claude', 'codex']);
+const SUPPORTED_TARGETS = new Set(listTargetNames());
+
+// Module-level cache: projectRoot → normalized styles
+const _cache = new Map();
+
+function clearStyleCache() {
+  _cache.clear();
+}
 
 function loadStyleRegistry(projectRoot) {
+  if (_cache.has(projectRoot)) return _cache.get(projectRoot);
+
   const registryPath = path.join(projectRoot, 'output-styles', 'index.json');
   const raw = fs.readFileSync(registryPath, 'utf8');
   const parsed = JSON.parse(raw);
   const styles = Array.isArray(parsed.styles) ? parsed.styles : null;
   if (!styles || styles.length === 0) {
-    throw new Error('output-styles/index.json 缺少 styles 列表');
+    throw new Error('output-styles/index.json 缺少 styles 列表. Check output-styles/index.json has a "styles" array');
   }
 
   const seen = new Set();
@@ -22,9 +32,10 @@ function loadStyleRegistry(projectRoot) {
   });
 
   if (defaultCount !== 1) {
-    throw new Error('style registry 必须且只能有一个 default style');
+    throw new Error('style registry 必须且只能有一个 default style. Check output-styles/index.json — exactly one entry must have "default: true"');
   }
 
+  _cache.set(projectRoot, normalized);
   return normalized;
 }
 
@@ -65,7 +76,7 @@ function requireNonEmptyString(value, fieldName) {
 }
 
 function normalizeTargets(targets, slug) {
-  const values = Array.isArray(targets) && targets.length > 0 ? targets : ['claude', 'codex'];
+  const values = Array.isArray(targets) && targets.length > 0 ? targets : listTargetNames();
   values.forEach((target) => {
     if (!SUPPORTED_TARGETS.has(target)) {
       throw new Error(`style ${slug} 包含不支持的 target: ${target}`);
@@ -99,10 +110,10 @@ function readStyleContent(projectRoot, style) {
   return fs.readFileSync(stylePath, 'utf8');
 }
 
-function renderCodexAgents(projectRoot, styleSlug) {
-  const style = resolveStyle(projectRoot, styleSlug, 'codex');
+function renderRuntimeGuidance(projectRoot, styleSlug, targetName = 'codex') {
+  const style = resolveStyle(projectRoot, styleSlug, targetName === 'gemini' ? 'claude' : targetName);
   if (!style) {
-    throw new Error(`未知输出风格: ${styleSlug}`);
+    throw new Error(`未知输出风格: ${styleSlug}. Try: node bin/install.js --list-styles`);
   }
 
   const basePath = path.join(projectRoot, 'config', 'CLAUDE.md');
@@ -111,9 +122,20 @@ function renderCodexAgents(projectRoot, styleSlug) {
   return `${base}\n\n${styleContent}\n`;
 }
 
+function renderCodexAgents(projectRoot, styleSlug) {
+  return renderRuntimeGuidance(projectRoot, styleSlug, 'codex');
+}
+
+function renderGeminiContext(projectRoot, styleSlug) {
+  return renderRuntimeGuidance(projectRoot, styleSlug, 'gemini');
+}
+
 module.exports = {
   listStyles,
   getDefaultStyle,
   resolveStyle,
   renderCodexAgents,
+  renderGeminiContext,
+  renderRuntimeGuidance,
+  clearStyleCache,
 };

package/bin/lib/target-registry.js

@@ -0,0 +1,74 @@
+'use strict';
+
+const INSTALL_TARGETS = Object.freeze([
+  {
+    name: 'claude',
+    label: 'Claude Code',
+    actionLabel: 'Claude Code',
+    homeDir: '.claude',
+  },
+  {
+    name: 'codex',
+    label: 'Codex CLI',
+    actionLabel: 'Codex CLI',
+    homeDir: '.codex',
+  },
+  {
+    name: 'gemini',
+    label: 'Gemini CLI',
+    actionLabel: 'Gemini CLI',
+    homeDir: '.gemini',
+  },
+]);
+
+const MANAGED_ROOTS = Object.freeze({
+  claude: '.claude',
+  codex: '.codex',
+  agents: '.agents',
+  gemini: '.gemini',
+});
+
+function listInstallTargets() {
+  return INSTALL_TARGETS.slice();
+}
+
+function listTargetNames() {
+  return INSTALL_TARGETS.map((target) => target.name);
+}
+
+function isSupportedTarget(targetName) {
+  return listTargetNames().includes(targetName);
+}
+
+function getTargetMeta(targetName) {
+  return INSTALL_TARGETS.find((target) => target.name === targetName) || null;
+}
+
+function getManagedRootNames() {
+  return Object.keys(MANAGED_ROOTS);
+}
+
+function isManagedRoot(rootName) {
+  return Object.prototype.hasOwnProperty.call(MANAGED_ROOTS, rootName);
+}
+
+function getManagedRootRelativeDir(rootName) {
+  if (!isManagedRoot(rootName)) {
+    throw new Error(`不支持的安装根: ${rootName}`);
+  }
+  return MANAGED_ROOTS[rootName];
+}
+
+function formatTargetList(joiner = '|') {
+  return listTargetNames().join(joiner);
+}
+
+module.exports = {
+  listInstallTargets,
+  listTargetNames,
+  isSupportedTarget,
+  getTargetMeta,
+  getManagedRootNames,
+  getManagedRootRelativeDir,
+  formatTargetList,
+};

package/bin/lib/utils.js

@@ -6,18 +6,24 @@ const SKIP = ['__pycache__', '.pyc', '.pyo', '.egg-info', '.DS_Store', 'Thumbs.d
 
 function shouldSkip(name) { return SKIP.some(p => name.includes(p)); }
 
-function copyRecursive(src, dest) {
+function copyRecursive(src, dest, errors) {
   let stat;
   try { stat = fs.statSync(src); } catch (e) {
-    throw new Error(`复制失败: 源路径不存在 ${src} (${e.code})`);
+    const err = new Error(`复制失败: 源路径不存在 ${src} (${e.code})`);
+    if (errors) { errors.push({ src, dest, error: err }); return; }
+    throw err;
   }
   if (stat.isDirectory()) {
     if (shouldSkip(path.basename(src))) return;
     fs.mkdirSync(dest, { recursive: true });
     for (const f of fs.readdirSync(src)) {
       if (!shouldSkip(f)) {
-        try { copyRecursive(path.join(src, f), path.join(dest, f)); }
-        catch (e) { console.error(`  ⚠ 跳过: ${path.join(src, f)} (${e.message})`); }
+        try { copyRecursive(path.join(src, f), path.join(dest, f), errors); }
+        catch (e) {
+          const entry = { src: path.join(src, f), dest: path.join(dest, f), error: e };
+          if (errors) { errors.push(entry); }
+          else { console.error(`  ⚠ 跳过: ${entry.src} (${e.message})`); }
+        }
       }
     }
   } else {
@@ -85,9 +91,66 @@ function parseFrontmatter(content) {
     if (!m) {
       throw new Error(`frontmatter 第 ${index + 1} 行格式无效: ${rawLine}`);
     }
-    if (!UNSAFE_KEYS.has(m[1])) meta[m[1]] = m[2].trim().replace(/^["']|["']$/g, '');
+    if (UNSAFE_KEYS.has(m[1])) return;
+    let value = m[2].trim();
+    // Strip inline comments (unquoted # followed by space or end-of-line)
+    value = stripInlineComment(value);
+    // Handle YAML inline array syntax: [A, B, C] → "A, B, C"
+    if (/^\[.+\]$/.test(value)) {
+      value = value.slice(1, -1).split(',').map(s => s.trim().replace(/^["']|["']$/g, '')).join(', ');
+    } else {
+      value = value.replace(/^["']|["']$/g, '');
+    }
+    meta[m[1]] = value;
   });
   return meta;
 }
 
-module.exports = { shouldSkip, copyRecursive, rmSafe, deepMergeNew, printMergeLog, parseFrontmatter, SKIP };
+function stripInlineComment(value) {
+  // Preserve # inside quotes; strip unquoted # followed by space or EOL
+  let inQuote = false;
+  let quoteChar = '';
+  for (let i = 0; i < value.length; i++) {
+    const ch = value[i];
+    if (inQuote) {
+      if (ch === quoteChar) inQuote = false;
+    } else {
+      if (ch === '"' || ch === "'") {
+        inQuote = true;
+        quoteChar = ch;
+      } else if (ch === '#' && (i + 1 === value.length || value[i + 1] === ' ')) {
+        return value.slice(0, i).trimEnd();
+      }
+    }
+  }
+  return value;
+}
+
+function formatActionableError(message, suggestion) {
+  if (!suggestion) return message;
+  return `${message}. ${suggestion}`;
+}
+
+/**
+ * 轻量模板引擎 — 支持 {{key}} 变量替换 + {{#key}}...{{/key}} 条件包含 + {{^key}}...{{/key}} 反条件包含
+ * @param {string} template - 模板字符串
+ * @param {Object} data - 变量映射
+ * @returns {string} 渲染结果
+ */
+function renderTemplate(template, data) {
+  // {{^key}}...{{/key}} — 反条件（key 为 falsy 时包含）
+  template = template.replace(/\{\{\^(\w+)\}\}([\s\S]*?)\{\{\/\1\}\}/g, (_, key, body) => {
+    return data[key] ? '' : body;
+  });
+  // {{#key}}...{{/key}} — 正条件（key 为 truthy 时包含）
+  template = template.replace(/\{\{#(\w+)\}\}([\s\S]*?)\{\{\/\1\}\}/g, (_, key, body) => {
+    return data[key] ? body : '';
+  });
+  // {{key}} — 变量替换
+  template = template.replace(/\{\{(\w+)\}\}/g, (_, key) => {
+    return data[key] !== undefined ? String(data[key]) : `{{${key}}}`;
+  });
+  return template;
+}
+
+module.exports = { shouldSkip, copyRecursive, rmSafe, deepMergeNew, printMergeLog, parseFrontmatter, stripInlineComment, formatActionableError, renderTemplate, SKIP };

package/bin/lib/vendor-providers/archive.js

@@ -0,0 +1,56 @@
+'use strict';
+
+module.exports = {
+  name: 'archive',
+  validate(upstream) {
+    if (!upstream.path) {
+      throw new Error('upstream.provider=archive 时必须提供 path');
+    }
+  },
+  sync({ projectRoot, upstream, vendorDir, shared, packName }) {
+    const archivePath = shared.resolveUpstreamPath(projectRoot, upstream.path);
+    if (!archivePath || !shared.fs.existsSync(archivePath)) {
+      throw new Error(`archive 源不存在: ${archivePath || upstream.path}`);
+    }
+    shared.rmSafe(vendorDir);
+    shared.fs.mkdirSync(vendorDir, { recursive: true });
+    shared.extractArchive(archivePath, vendorDir);
+    shared.writeVendorMetadata(vendorDir, {
+      pack: packName,
+      provider: 'archive',
+      path: upstream.path,
+      version: upstream.version || '',
+      sourceSignature: shared.hashFile(archivePath),
+      vendorSignature: shared.hashDirectory(vendorDir),
+    });
+    return {
+      pack: packName,
+      provider: 'archive',
+      action: 'updated',
+      vendorDir,
+      repo: null,
+      commit: null,
+      version: upstream.version || '',
+    };
+  },
+  status({ projectRoot, upstream, vendorDir, shared, packName, metadata }) {
+    const archivePath = shared.resolveUpstreamPath(projectRoot, upstream.path);
+    const sourceExists = !!archivePath && shared.fs.existsSync(archivePath);
+    const sourceSignature = sourceExists ? shared.hashFile(archivePath) : null;
+    const vendorSignature = shared.hashDirectory(vendorDir);
+    const dirty = metadata && metadata.vendorSignature ? vendorSignature !== metadata.vendorSignature : true;
+
+    return {
+      pack: packName,
+      provider: 'archive',
+      vendorDir,
+      exists: true,
+      dirty,
+      drifted: !sourceExists || sourceSignature !== (metadata && metadata.sourceSignature),
+      currentCommit: null,
+      targetCommit: null,
+      sourceExists,
+      metadata,
+    };
+  },
+};

package/bin/lib/vendor-providers/git.js

@@ -0,0 +1,59 @@
+'use strict';
+
+module.exports = {
+  name: 'git',
+  validate(upstream) {
+    if (!upstream.repo || !upstream.commit) {
+      throw new Error('upstream.provider=git 时必须提供 repo 和 commit');
+    }
+  },
+  sync({ upstream, vendorDir, shared, packName }) {
+    let action = shared.fs.existsSync(vendorDir) ? 'updated' : 'cloned';
+    if (!shared.fs.existsSync(vendorDir)) {
+      shared.runGit(['clone', '--depth', '1', upstream.repo, vendorDir]);
+    }
+    shared.runGit(['fetch', '--depth', '1', 'origin', upstream.commit], vendorDir);
+    shared.runGit(['checkout', '--detach', upstream.commit], vendorDir);
+    shared.writeVendorMetadata(vendorDir, {
+      pack: packName,
+      provider: 'git',
+      repo: upstream.repo,
+      commit: upstream.commit,
+      version: upstream.version || '',
+      sourceSignature: upstream.commit,
+      vendorSignature: shared.hashDirectory(vendorDir),
+    });
+    return {
+      pack: packName,
+      provider: 'git',
+      action,
+      vendorDir,
+      repo: upstream.repo,
+      commit: upstream.commit,
+      version: upstream.version || '',
+    };
+  },
+  status({ upstream, vendorDir, shared, packName, metadata }) {
+    let currentCommit = null;
+    try {
+      currentCommit = shared.runGit(['rev-parse', 'HEAD'], vendorDir);
+    } catch {
+      currentCommit = null;
+    }
+    const vendorSignature = shared.hashDirectory(vendorDir);
+    const dirty = metadata && metadata.vendorSignature ? vendorSignature !== metadata.vendorSignature : true;
+
+    return {
+      pack: packName,
+      provider: 'git',
+      vendorDir,
+      exists: true,
+      dirty,
+      drifted: currentCommit !== upstream.commit,
+      currentCommit,
+      targetCommit: upstream.commit,
+      sourceExists: true,
+      metadata,
+    };
+  },
+};

package/bin/lib/vendor-providers/index.js

@@ -0,0 +1,91 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+const shared = require('./shared');
+
+const BUILTIN_DIR = __dirname;
+const BUILTIN_SKIP = new Set(['index.js', 'shared.js']);
+
+function isProviderFile(name) {
+  return name.endsWith('.js') && !BUILTIN_SKIP.has(name);
+}
+
+function validateProviderContract(provider, sourcePath) {
+  if (!provider || typeof provider !== 'object') {
+    throw new Error(`vendor provider 无效: ${sourcePath}`);
+  }
+  if (typeof provider.name !== 'string' || provider.name.trim() === '') {
+    throw new Error(`vendor provider 缺少 name: ${sourcePath}`);
+  }
+  ['validate', 'sync', 'status'].forEach((fn) => {
+    if (typeof provider[fn] !== 'function') {
+      throw new Error(`vendor provider 缺少 ${fn}(): ${sourcePath}`);
+    }
+  });
+}
+
+function loadProvidersFromDir(dirPath) {
+  if (!dirPath || !fs.existsSync(dirPath)) return [];
+
+  return fs.readdirSync(dirPath)
+    .filter(isProviderFile)
+    .sort()
+    .map((fileName) => {
+      const fullPath = path.join(dirPath, fileName);
+      delete require.cache[require.resolve(fullPath)];
+      const provider = require(fullPath);
+      validateProviderContract(provider, fullPath);
+      return {
+        name: provider.name,
+        provider,
+        sourcePath: fullPath,
+      };
+    });
+}
+
+function getDynamicProviderDirs(projectRoot) {
+  if (!projectRoot) return [];
+  return [
+    path.join(projectRoot, '.code-abyss', 'vendor-providers'),
+    path.join(projectRoot, 'vendor-providers'),
+  ];
+}
+
+function loadVendorProviders(projectRoot = null) {
+  const providers = new Map();
+
+  loadProvidersFromDir(BUILTIN_DIR).forEach(({ name, provider }) => {
+    providers.set(name, provider);
+  });
+
+  getDynamicProviderDirs(projectRoot).forEach((dirPath) => {
+    loadProvidersFromDir(dirPath).forEach(({ name, provider }) => {
+      providers.set(name, provider);
+    });
+  });
+
+  return providers;
+}
+
+function listVendorProviderNames(projectRoot = null) {
+  return [...loadVendorProviders(projectRoot).keys()].sort();
+}
+
+function getVendorProvider(providerName = 'git', projectRoot = null) {
+  const provider = loadVendorProviders(projectRoot).get(providerName);
+  if (!provider) {
+    throw new Error(`不支持的 vendor provider: ${providerName}`);
+  }
+  return provider;
+}
+
+module.exports = {
+  shared,
+  BUILTIN_DIR,
+  loadVendorProviders,
+  listVendorProviderNames,
+  getVendorProvider,
+  validateProviderContract,
+};

package/bin/lib/vendor-providers/local-dir.js

@@ -0,0 +1,55 @@
+'use strict';
+
+module.exports = {
+  name: 'local-dir',
+  validate(upstream) {
+    if (!upstream.path) {
+      throw new Error('upstream.provider=local-dir 时必须提供 path');
+    }
+  },
+  sync({ projectRoot, upstream, vendorDir, shared, packName }) {
+    const sourcePath = shared.resolveUpstreamPath(projectRoot, upstream.path);
+    if (!sourcePath || !shared.fs.existsSync(sourcePath)) {
+      throw new Error(`local-dir 源不存在: ${sourcePath || upstream.path}`);
+    }
+    shared.rmSafe(vendorDir);
+    shared.copyRecursive(sourcePath, vendorDir);
+    shared.writeVendorMetadata(vendorDir, {
+      pack: packName,
+      provider: 'local-dir',
+      path: upstream.path,
+      version: upstream.version || '',
+      sourceSignature: shared.hashDirectory(sourcePath),
+      vendorSignature: shared.hashDirectory(vendorDir),
+    });
+    return {
+      pack: packName,
+      provider: 'local-dir',
+      action: 'updated',
+      vendorDir,
+      repo: null,
+      commit: null,
+      version: upstream.version || '',
+    };
+  },
+  status({ projectRoot, upstream, vendorDir, shared, packName, metadata }) {
+    const sourcePath = shared.resolveUpstreamPath(projectRoot, upstream.path);
+    const sourceExists = !!sourcePath && shared.fs.existsSync(sourcePath);
+    const sourceSignature = sourceExists ? shared.hashDirectory(sourcePath) : null;
+    const vendorSignature = shared.hashDirectory(vendorDir);
+    const dirty = metadata && metadata.vendorSignature ? vendorSignature !== metadata.vendorSignature : true;
+
+    return {
+      pack: packName,
+      provider: 'local-dir',
+      vendorDir,
+      exists: true,
+      dirty,
+      drifted: !sourceExists || sourceSignature !== (metadata && metadata.sourceSignature),
+      currentCommit: null,
+      targetCommit: null,
+      sourceExists,
+      metadata,
+    };
+  },
+};