@mohammadhprp/system-prompt 0.13.1 → 0.13.2

package/src/{agent-configs.js → config/tui.js}

@@ -1,79 +1,3 @@
-import { fileURLToPath } from 'node:url';
-import { dirname, resolve } from 'node:path';
-import { readFile } from 'node:fs/promises';
-
-const __dirname = dirname(fileURLToPath(import.meta.url));
-const packageRoot = resolve(__dirname, '..');
-
-export async function loadMcpConfigs(selectedIds) {
-  const entries = {};
-  for (const id of selectedIds) {
-    try {
-      const configPath = resolve(packageRoot, `framework/mcps/${id}/configs/opencode.json`);
-      const raw = await readFile(configPath, 'utf-8');
-      const parsed = JSON.parse(raw);
-      if (parsed.mcp) {
-        Object.assign(entries, parsed.mcp);
-      }
-    } catch (error) {
-      if (error.code === 'ENOENT') {
-        console.warn(`  ⚠  No opencode.json config found for MCP: ${id}`);
-        continue;
-      }
-      throw error;
-    }
-  }
-  return entries;
-}
-
-export function generateOpenCodeConfig({ selections, mcpEntries, includeAgentsMd }) {
-  const plugins = [];
-  if (selections.plugins?.includes('opencode-goal-plugin')) {
-    plugins.push('@prevalentware/opencode-goal-plugin');
-  }
-  if (selections.plugins?.includes('ponytail')) {
-    plugins.push('@dietrichgebert/ponytail');
-  }
-
-  const instructions = [];
-  if (includeAgentsMd) instructions.push('AGENTS.md');
-  if (selections.memory?.length) instructions.push('.opencode/memory/*.md');
-
-  const config = {
-    $schema: 'https://opencode.ai/config.json',
-    formatter: true,
-    lsp: false,
-    instructions,
-  };
-
-  if (plugins.length > 0) {
-    config.plugin = plugins;
-  }
-
-  const references = {};
-  if (selections.standards?.length) {
-    references.standards = {
-      path: 'references/standards',
-      description: 'Canonical engineering standards referenced by skills.',
-    };
-  }
-  if (selections.templates?.length) {
-    references.templates = {
-      path: 'references/templates',
-      description: 'Ready-to-use workflow documents.',
-    };
-  }
-  if (Object.keys(references).length > 0) {
-    config.references = references;
-  }
-
-  if (Object.keys(mcpEntries).length > 0) {
-    config.mcp = mcpEntries;
-  }
-
-  return JSON.stringify(config, null, 4);
-}
-
 export const TUI_THEMES = [
   'system',
   'tokyonight',

package/src/doctor.js

@@ -1,10 +1,12 @@
 import { resolve } from 'node:path';
 import { access, readFile } from 'node:fs/promises';
-import { createHash } from 'node:crypto';
 
 import { categories } from './catalog.js';
-import { loadLockFile, lockToSelections } from './installer.js';
+import { hash } from './hash.js';
 import { itemRelativePath } from './item-layout.js';
+import { loadLockFile, lockToSelections } from './install/lock.js';
+import { isMissing } from './paths.js';
+import { status } from './ui.js';
 
 async function exists(path) {
   try {
@@ -17,10 +19,10 @@ async function exists(path) {
 
 async function checkManagedFile(absTarget, relativePath, expectedHash, issues) {
   try {
-    const actual = createHash('sha256').update(await readFile(resolve(absTarget, relativePath))).digest('hex');
+    const actual = hash(await readFile(resolve(absTarget, relativePath)));
     if (actual !== expectedHash) issues.push(`Modified managed file: ${relativePath}`);
   } catch (error) {
-    if (error.code === 'ENOENT') issues.push(`Missing managed file: ${relativePath}`);
+    if (isMissing(error)) issues.push(`Missing managed file: ${relativePath}`);
     else throw error;
   }
 }
@@ -85,11 +87,12 @@ export async function inspectInstallation(targetDir) {
 
 export async function doctor(targetDir = '.opencode', output = console.log) {
   const result = await inspectInstallation(targetDir);
-  output(`Checking ${result.targetDir}`);
+  output(status('info', `Checking ${result.targetDir}`));
   if (result.issues.length === 0) {
-    output('No issues found.');
+    output(status('success', 'No issues found.'));
     return true;
   }
-  for (const issue of result.issues) output(`  ⚠  ${issue}`);
+  output(status('error', `${result.issues.length} issue${result.issues.length === 1 ? '' : 's'} found:`));
+  for (const issue of result.issues) output(`  ${status('warn', issue)}`);
   return false;
 }

package/src/hash.js

@@ -0,0 +1,5 @@
+import { createHash } from 'node:crypto';
+
+export function hash(content) {
+  return createHash('sha256').update(content).digest('hex');
+}

package/src/install/env.js

@@ -0,0 +1,69 @@
+import { readFile, writeFile } from 'node:fs/promises';
+import { resolve } from 'node:path';
+
+import { hash } from '../hash.js';
+import { assertSafeDestination, isMissing, resolveSource } from '../paths.js';
+
+export async function collectMcpEnvExamples(mcpIds) {
+  const combined = new Map();
+  for (const id of mcpIds) {
+    try {
+      const examplePath = resolveSource(`framework/mcps/${id}/configs/.env.example`);
+      const content = await readFile(examplePath, 'utf-8');
+      const parsed = parseEnv(content);
+      for (const [key, value] of parsed) {
+        if (!combined.has(key)) combined.set(key, value);
+      }
+    } catch (error) {
+      if (!isMissing(error)) throw error;
+      // MCPs may not provide an environment example.
+    }
+  }
+  return combined;
+}
+
+export async function writeMergedEnv(absTarget, examples, options) {
+  if (examples.size === 0) return;
+
+  const envPath = resolve(absTarget, '.env');
+  await assertSafeDestination(options.targetDir, envPath);
+  const existing = new Map();
+  let existingContent = '';
+
+  try {
+    existingContent = await readFile(envPath, 'utf-8');
+    const parsed = parseEnv(existingContent);
+    for (const [key, value] of parsed) existing.set(key, value);
+  } catch (error) {
+    if (!isMissing(error)) throw error;
+  }
+
+  const additions = [];
+  for (const [key, value] of examples) {
+    if (!existing.has(key)) additions.push(`${key}=${value}`);
+  }
+
+  if (additions.length === 0) return;
+  const separator = existingContent && !existingContent.endsWith('\n') ? '\n' : '';
+  const content = Buffer.from(`${existingContent}${separator}${additions.join('\n')}\n`);
+  if (!options.dryRun) await writeFile(envPath, content);
+  options.managedFiles['.env'] = hash(content);
+  options.fileOwners['.env'] = { generated: true };
+}
+
+function parseEnv(content) {
+  const vars = new Map();
+  for (const line of content.split('\n')) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith('#')) continue;
+    const eqIndex = trimmed.indexOf('=');
+    if (eqIndex === -1) {
+      vars.set(trimmed, '');
+    } else {
+      const key = trimmed.slice(0, eqIndex).trim();
+      const value = trimmed.slice(eqIndex + 1).trim();
+      if (key) vars.set(key, value);
+    }
+  }
+  return vars;
+}

package/src/install/files.js

@@ -0,0 +1,151 @@
+import { mkdir, readdir, readFile, rm, stat, writeFile } from 'node:fs/promises';
+import { dirname, resolve } from 'node:path';
+
+import { categories } from '../catalog.js';
+import { hash } from '../hash.js';
+import {
+  isCopyable,
+  isFileBased,
+  isRemoved,
+  itemRelativePath,
+  itemSourcePath,
+  targetSubdir,
+} from '../item-layout.js';
+import { assertSafeDestination, isMissing, resolveSource } from '../paths.js';
+import { status } from '../ui.js';
+import { getExpectedHash } from './lock.js';
+
+async function canWrite(destFile, relativePath, oldLock, force) {
+  if (force) return true;
+  try {
+    const existing = await readFile(destFile);
+    const previousHash = getExpectedHash(oldLock, relativePath);
+    return Boolean(previousHash && previousHash === hash(existing));
+  } catch (error) {
+    if (isMissing(error)) return true;
+    throw error;
+  }
+}
+
+export async function writeManagedFile(destFile, content, relativePath, options, owner) {
+  await assertSafeDestination(options.targetDir, destFile);
+  if (!options.allowExistingMerge && !(await canWrite(destFile, relativePath, options.oldLock, options.force))) {
+    console.warn(status('warn', `Preserving existing file: ${relativePath}`));
+    return false;
+  }
+  if (!options.dryRun) await mkdir(dirname(destFile), { recursive: true });
+  if (!options.dryRun) await writeFile(destFile, content);
+  options.managedFiles[relativePath] = hash(content);
+  if (owner) options.fileOwners[relativePath] = owner;
+  return true;
+}
+
+async function copyDir(src, dest, relativeDir, options, owner) {
+  if (!options.dryRun) await mkdir(dest, { recursive: true });
+  const entries = await readdir(src, { withFileTypes: true });
+
+  for (const entry of entries) {
+    if (entry.name === '.DS_Store') continue;
+    const srcPath = resolve(src, entry.name);
+    const destPath = resolve(dest, entry.name);
+    const relativePath = `${relativeDir}/${entry.name}`;
+
+    if (entry.isDirectory()) {
+      await copyDir(srcPath, destPath, relativePath, options, owner);
+    } else if (entry.isFile()) {
+      const content = await readFile(srcPath);
+      await writeManagedFile(destPath, content, relativePath, options, owner);
+    }
+  }
+}
+
+export async function copySelectedDirs(targetDir, category, selectedIds, options) {
+  const catConfig = categories[category];
+  if (!catConfig || !selectedIds?.length) return;
+
+  const destParent = resolve(targetDir, targetSubdir(catConfig.sourceDir));
+
+  for (const id of selectedIds) {
+    if (isRemoved(category, id)) continue;
+
+    const source = itemSourcePath(category, id);
+    const srcPath = resolveSource(source);
+    const destPath = resolve(destParent, id);
+    await assertSafeDestination(targetDir, destPath);
+
+    try {
+      await stat(srcPath);
+      await copyDir(srcPath, destPath, itemRelativePath(category, id), options, { category, id });
+    } catch (error) {
+      if (isMissing(error)) {
+        console.warn(status('warn', `Source not found: ${source}`));
+        continue;
+      }
+      throw error;
+    }
+  }
+}
+
+export async function copySelectedFiles(targetDir, category, selectedIds, options) {
+  const catConfig = categories[category];
+  if (!catConfig || !selectedIds?.length) return;
+
+  const destParent = resolve(targetDir, targetSubdir(catConfig.sourceDir));
+  if (!options.dryRun) await mkdir(destParent, { recursive: true });
+
+  for (const id of selectedIds) {
+    if (isRemoved(category, id)) continue;
+
+    const source = itemSourcePath(category, id);
+    const relativePath = itemRelativePath(category, id);
+    const destFile = resolve(targetDir, relativePath);
+    await assertSafeDestination(targetDir, destFile);
+    try {
+      const content = await readFile(resolveSource(source));
+      await writeManagedFile(destFile, content, relativePath, options, { category, id });
+    } catch (error) {
+      if (isMissing(error)) {
+        console.warn(status('warn', `Source not found: ${source}`));
+        continue;
+      }
+      throw error;
+    }
+  }
+}
+
+export async function deleteSelectedItems(absTarget, category, ids, oldLock, force, dryRun) {
+  if (!categories[category] || !ids?.length || !isCopyable(category)) return;
+
+  for (const id of ids) {
+    const relativePath = itemRelativePath(category, id);
+    const destPath = resolve(absTarget, relativePath);
+    await assertSafeDestination(absTarget, destPath);
+    if (!force && oldLock) {
+      const managedEntries = Object.entries(oldLock?.[category]?.[id]?.files || {});
+      if (managedEntries.length === 0) {
+        console.warn(status('warn', `Preserving unmanaged item: ${relativePath}`));
+        continue;
+      }
+      let modified = false;
+      for (const [path, checksum] of managedEntries) {
+        await assertSafeDestination(absTarget, resolve(absTarget, path));
+        try {
+          if (hash(await readFile(resolve(absTarget, path))) !== checksum) modified = true;
+        } catch (error) {
+          if (!isMissing(error)) throw error;
+        }
+      }
+      if (modified) {
+        console.warn(status('warn', `Preserving modified item: ${relativePath}`));
+        continue;
+      }
+      if (!isFileBased(category)) {
+        if (!dryRun) {
+          for (const [path] of managedEntries) await rm(resolve(absTarget, path), { force: true });
+        }
+        continue;
+      }
+    }
+    if (!dryRun) await rm(destPath, { recursive: true, force: true });
+  }
+}

package/src/install/index.js

@@ -0,0 +1,124 @@
+import { mkdir } from 'node:fs/promises';
+import { resolve } from 'node:path';
+
+import { categories } from '../catalog.js';
+import { loadMcpConfigs } from '../config/mcp.js';
+import { generateOpenCodeConfig } from '../config/opencode.js';
+import { generateTuiConfig } from '../config/tui.js';
+import { LOCK_CATEGORIES, isCopyable, isFileBased } from '../item-layout.js';
+import { getPackageVersion } from '../paths.js';
+import { collectMcpEnvExamples, writeMergedEnv } from './env.js';
+import { copySelectedDirs, copySelectedFiles, deleteSelectedItems, writeManagedFile } from './files.js';
+import { createLockData, lockToSelections, validateLock, writeLockFile } from './lock.js';
+import { mergeGitignore, mergeJsonFile } from './merge.js';
+import { AGENTS_MD } from './templates.js';
+
+export function validateSelections(selections) {
+  if (!selections || typeof selections !== 'object' || Array.isArray(selections)) {
+    throw new Error('Selections must be an object');
+  }
+  for (const [category, ids] of Object.entries(selections)) {
+    const config = categories[category];
+    if (!config || !Array.isArray(ids)) throw new Error(`Unknown or invalid category: ${category}`);
+    const knownIds = new Set(config.items.map(item => item.id));
+    if (ids.some(id => !knownIds.has(id))) throw new Error(`Unknown ${category} item selected`);
+  }
+  return selections;
+}
+
+export async function install({ targetDir, agentType, selections, includeAgentsMd = true, writeAgentsMd, oldSelections, oldLock, force = false, dryRun = false, tuiPreferences }) {
+  validateSelections(selections);
+  if (oldLock) validateLock(oldLock);
+  writeAgentsMd = writeAgentsMd ?? includeAgentsMd;
+  const absTarget = resolve(process.cwd(), targetDir);
+  if (!dryRun) await mkdir(absTarget, { recursive: true });
+  const options = {
+    targetDir: absTarget,
+    oldLock,
+    force,
+    dryRun,
+    managedFiles: {},
+    fileOwners: {},
+  };
+  if (oldLock) {
+    for (const category of LOCK_CATEGORIES) {
+      for (const [id, entry] of Object.entries(oldLock[category] || {})) {
+        for (const [path, checksum] of Object.entries(entry.files || {})) {
+          if (!(path in options.managedFiles)) {
+            options.managedFiles[path] = checksum;
+            options.fileOwners[path] = { category, id };
+          }
+        }
+      }
+    }
+    for (const [path, entry] of Object.entries(oldLock.generated || {})) {
+      if (!(path in options.managedFiles)) {
+        options.managedFiles[path] = entry.computedHash;
+        options.fileOwners[path] = { generated: true };
+      }
+    }
+  }
+
+  // Delete items that are no longer selected.
+  if (oldSelections) {
+    for (const cat of Object.keys(oldSelections)) {
+      const oldIds = new Set(oldSelections[cat] || []);
+      const newIds = new Set(selections[cat] || []);
+      const removedIds = [...oldIds].filter(id => !newIds.has(id));
+      await deleteSelectedItems(absTarget, cat, removedIds, oldLock, force, dryRun);
+    }
+  }
+
+  const tasks = [];
+  for (const category of LOCK_CATEGORIES) {
+    if (!isCopyable(category) || !selections[category]?.length) continue;
+    tasks.push(isFileBased(category)
+      ? copySelectedFiles(absTarget, category, selections[category], options)
+      : copySelectedDirs(absTarget, category, selections[category], options));
+  }
+  await Promise.all(tasks);
+
+  if (writeAgentsMd) {
+    await writeManagedFile(resolve(absTarget, 'AGENTS.md'), Buffer.from(AGENTS_MD), 'AGENTS.md', options, { generated: true });
+  }
+
+  if (agentType === 'opencode') {
+    let mcpEntries = {};
+    if (selections.mcps?.length) mcpEntries = await loadMcpConfigs(selections.mcps);
+    let previousOpenCodeConfig;
+    let previousTuiConfig;
+    if (oldLock) {
+      const previousSelections = lockToSelections(oldLock);
+      let previousMcpEntries = {};
+      if (previousSelections.mcps?.length) previousMcpEntries = await loadMcpConfigs(previousSelections.mcps);
+      previousOpenCodeConfig = JSON.parse(generateOpenCodeConfig({
+        selections: previousSelections,
+        mcpEntries: previousMcpEntries,
+        includeAgentsMd: oldLock.includeAgentsMd ?? true,
+      }));
+      previousTuiConfig = JSON.parse(generateTuiConfig({ selections: previousSelections, preferences: tuiPreferences }));
+    }
+    const configJson = generateOpenCodeConfig({ selections, mcpEntries, includeAgentsMd });
+    await mergeJsonFile(resolve(absTarget, 'opencode.json'), JSON.parse(configJson), 'opencode.json', options, previousOpenCodeConfig);
+    await mergeJsonFile(resolve(absTarget, 'tui.json'), JSON.parse(generateTuiConfig({ selections, preferences: tuiPreferences })), 'tui.json', options, previousTuiConfig);
+    await mergeGitignore(resolve(absTarget, '.gitignore'), options);
+  }
+
+  if (selections.mcps?.length) {
+    const envExamples = await collectMcpEnvExamples(selections.mcps);
+    await writeMergedEnv(absTarget, envExamples, options);
+  }
+
+  if (dryRun) return absTarget;
+  const pkgVersion = await getPackageVersion();
+  const lockData = createLockData({
+    agentType,
+    includeAgentsMd,
+    selections,
+    managedFiles: options.managedFiles,
+    fileOwners: options.fileOwners,
+    source: `system-prompt@${pkgVersion}`,
+  });
+  await writeLockFile(absTarget, lockData);
+  return absTarget;
+}

package/src/install/lock.js

@@ -0,0 +1,159 @@
+import { readFile, writeFile } from 'node:fs/promises';
+import { resolve } from 'node:path';
+
+import { categories } from '../catalog.js';
+import { hash } from '../hash.js';
+import { LOCK_CATEGORIES, isRemoved, itemSourcePath } from '../item-layout.js';
+import { isMissing } from '../paths.js';
+
+export const LOCK_VERSION = 1;
+
+export function lockToSelections(lock) {
+  const selections = {};
+  if (!lock) return selections;
+  for (const category of LOCK_CATEGORIES) {
+    const ids = Object.keys(lock[category] || {});
+    if (ids.length) selections[category] = ids;
+  }
+  return selections;
+}
+
+export function getExpectedHash(oldLock, relativePath) {
+  const generated = oldLock?.generated?.[relativePath]?.computedHash;
+  if (generated) return generated;
+  for (const category of LOCK_CATEGORIES) {
+    const entries = oldLock?.[category];
+    if (!entries) continue;
+    for (const entry of Object.values(entries)) {
+      const value = entry?.files?.[relativePath];
+      if (value) return value;
+    }
+  }
+  return undefined;
+}
+
+export async function loadLockFile(absTarget) {
+  try {
+    const content = await readFile(resolve(absTarget, 'system-prompt-lock.json'), 'utf-8');
+    const lock = JSON.parse(content);
+    validateLock(lock);
+    return lock;
+  } catch (error) {
+    if (isMissing(error)) return null;
+    if (error instanceof SyntaxError || error.message?.startsWith('Invalid system-prompt lock')) {
+      throw new Error(`${error.message}. Remove or repair system-prompt-lock.json before reinstalling.`);
+    }
+    throw error;
+  }
+}
+
+export function validateLock(lock) {
+  if (!lock || typeof lock !== 'object' || Array.isArray(lock)) {
+    throw new Error('Invalid system-prompt lock: expected an object');
+  }
+  if (lock.selections !== undefined || lock.managedFiles !== undefined) {
+    throw new Error('Invalid system-prompt lock: legacy lock format no longer supported');
+  }
+  if (lock.version !== LOCK_VERSION) {
+    throw new Error('Invalid system-prompt lock: unsupported version');
+  }
+  if (typeof lock.agentType !== 'string' || typeof lock.installedAt !== 'string') {
+    throw new Error('Invalid system-prompt lock: missing installation metadata');
+  }
+  if (typeof lock.includeAgentsMd !== 'boolean') {
+    throw new Error('Invalid system-prompt lock: includeAgentsMd must be a boolean');
+  }
+  const allowed = new Set(['version', 'agentType', 'installedAt', 'includeAgentsMd', 'generated', ...LOCK_CATEGORIES]);
+  for (const key of Object.keys(lock)) {
+    if (!allowed.has(key)) {
+      throw new Error(`Invalid system-prompt lock: unknown key ${key}`);
+    }
+  }
+  for (const category of LOCK_CATEGORIES) {
+    const entries = lock[category];
+    if (entries === undefined) continue;
+    if (!entries || typeof entries !== 'object' || Array.isArray(entries)) {
+      throw new Error(`Invalid system-prompt lock: invalid ${category} selection`);
+    }
+    const config = categories[category];
+    const knownIds = new Set(config.items.map(item => item.id));
+    for (const [id, entry] of Object.entries(entries)) {
+      if (!knownIds.has(id)) {
+        throw new Error(`Invalid system-prompt lock: unknown ${category} item`);
+      }
+      if (!entry || typeof entry !== 'object' || Array.isArray(entry)) {
+        throw new Error(`Invalid system-prompt lock: invalid ${category} entry`);
+      }
+      if (typeof entry.source !== 'string' || typeof entry.sourceType !== 'string' || typeof entry.itemPath !== 'string') {
+        throw new Error(`Invalid system-prompt lock: invalid ${category} entry source`);
+      }
+      if (!/^[a-f0-9]{64}$/.test(entry.computedHash || '')) {
+        throw new Error(`Invalid system-prompt lock: invalid ${category} entry hash`);
+      }
+      if (!entry.files || typeof entry.files !== 'object' || Array.isArray(entry.files)) {
+        throw new Error(`Invalid system-prompt lock: invalid ${category} entry files`);
+      }
+      for (const [path, checksum] of Object.entries(entry.files)) {
+        if (path.startsWith('/') || path.split('/').includes('..') || !/^[a-f0-9]{64}$/.test(checksum)) {
+          throw new Error('Invalid system-prompt lock: unsafe managed file entry');
+        }
+      }
+    }
+  }
+  const generated = lock.generated;
+  if (generated !== undefined) {
+    if (!generated || typeof generated !== 'object' || Array.isArray(generated)) {
+      throw new Error('Invalid system-prompt lock: generated must be an object');
+    }
+    for (const [path, entry] of Object.entries(generated)) {
+      if (path.startsWith('/') || path.split('/').includes('..') || !/^[a-f0-9]{64}$/.test(entry?.computedHash || '')) {
+        throw new Error('Invalid system-prompt lock: unsafe generated file entry');
+      }
+    }
+  }
+}
+
+export function createLockData({ agentType, includeAgentsMd, selections, managedFiles, fileOwners, source }) {
+  const lockData = {
+    version: LOCK_VERSION,
+    agentType,
+    installedAt: new Date().toISOString(),
+    includeAgentsMd,
+  };
+  for (const category of LOCK_CATEGORIES) {
+    const entries = {};
+    for (const id of selections[category] || []) {
+      if (isRemoved(category, id)) continue;
+      const files = {};
+      for (const [path, checksum] of Object.entries(managedFiles)) {
+        const owner = fileOwners[path];
+        if (owner?.category === category && owner?.id === id) files[path] = checksum;
+      }
+      entries[id] = {
+        source,
+        sourceType: 'bundled',
+        itemPath: itemSourcePath(category, id),
+        computedHash: buildComputedHash(files, id),
+        files,
+      };
+    }
+    lockData[category] = entries;
+  }
+  const generated = {};
+  for (const [path, checksum] of Object.entries(managedFiles)) {
+    if (fileOwners[path]?.generated) generated[path] = { computedHash: checksum };
+  }
+  lockData.generated = generated;
+  return lockData;
+}
+
+export async function writeLockFile(absTarget, lockData) {
+  await writeFile(resolve(absTarget, 'system-prompt-lock.json'), JSON.stringify(lockData, null, 2));
+}
+
+function buildComputedHash(files, fallbackId) {
+  const keys = Object.keys(files).sort();
+  if (keys.length === 0) return hash(fallbackId);
+  if (keys.length === 1) return files[keys[0]];
+  return hash(keys.map(path => `${path}:${files[path]}`).join('\n'));
+}