@mohammadhprp/system-prompt 0.12.6 → 0.13.1

package/src/doctor.js

@@ -3,7 +3,8 @@ import { access, readFile } from 'node:fs/promises';
 import { createHash } from 'node:crypto';
 
 import { categories } from './catalog.js';
-import { loadLockFile } from './installer.js';
+import { loadLockFile, lockToSelections } from './installer.js';
+import { itemRelativePath } from './item-layout.js';
 
 async function exists(path) {
   try {
@@ -14,6 +15,16 @@ async function exists(path) {
   }
 }
 
+async function checkManagedFile(absTarget, relativePath, expectedHash, issues) {
+  try {
+    const actual = createHash('sha256').update(await readFile(resolve(absTarget, relativePath))).digest('hex');
+    if (actual !== expectedHash) issues.push(`Modified managed file: ${relativePath}`);
+  } catch (error) {
+    if (error.code === 'ENOENT') issues.push(`Missing managed file: ${relativePath}`);
+    else throw error;
+  }
+}
+
 export async function inspectInstallation(targetDir) {
   const absTarget = resolve(process.cwd(), targetDir);
   const issues = [];
@@ -31,24 +42,24 @@ export async function inspectInstallation(targetDir) {
     return { targetDir: absTarget, issues };
   }
 
-  for (const [path, expected] of Object.entries(lock.managedFiles || {})) {
-    try {
-      const actual = createHash('sha256').update(await readFile(resolve(absTarget, path))).digest('hex');
-      if (actual !== expected) issues.push(`Modified managed file: ${path}`);
-    } catch (error) {
-      if (error.code === 'ENOENT') issues.push(`Missing managed file: ${path}`);
-      else throw error;
+  for (const [path, entry] of Object.entries(lock.generated || {})) {
+    await checkManagedFile(absTarget, path, entry.computedHash, issues);
+  }
+
+  for (const [category, entries] of Object.entries(lock)) {
+    if (!categories[category]) continue;
+    for (const entry of Object.values(entries)) {
+      for (const [path, expected] of Object.entries(entry.files || {})) {
+        await checkManagedFile(absTarget, path, expected, issues);
+      }
     }
   }
 
-  for (const [category, ids] of Object.entries(lock.selections)) {
+  for (const [category, ids] of Object.entries(lockToSelections(lock))) {
     const config = categories[category];
     for (const id of ids) {
       const item = config.items.find(entry => entry.id === id);
-      const relativePath = ['agents', 'commands', 'memory', 'modes', 'standards', 'templates'].includes(category)
-        ? `${config.sourceDir.replace(/^framework\//, '')}/${id}.md`
-        : `${config.sourceDir.replace(/^framework\//, '')}/${id}`;
-      if (!item || !(await exists(resolve(absTarget, relativePath)))) {
+      if (!item || !(await exists(resolve(absTarget, itemRelativePath(category, id))))) {
         issues.push(`Missing installed ${category} item: ${id}`);
       }
     }

package/src/installer.js

@@ -5,6 +5,7 @@ import { createHash } from 'node:crypto';
 
 import { categories } from './catalog.js';
 import { loadMcpConfigs, generateOpenCodeConfig, generateTuiConfig } from './agent-configs.js';
+import { LOCK_CATEGORIES, isFileBased, isCopyable, itemSourcePath, itemRelativePath, targetSubdir } from './item-layout.js';
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const packageRoot = resolve(__dirname, '..');
@@ -86,6 +87,38 @@ package-lock.json
 bun.lock
 `;
 
+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;
+}
+
+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'));
+}
+
+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 getPackageVersion() {
   try {
     const pkg = JSON.parse(await readFile(resolve(packageRoot, 'package.json'), 'utf-8'));
@@ -114,26 +147,63 @@ function validateLock(lock) {
   if (!lock || typeof lock !== 'object' || Array.isArray(lock)) {
     throw new Error('Invalid system-prompt lock: expected an object');
   }
-  if (!lock.selections || typeof lock.selections !== 'object' || Array.isArray(lock.selections)) {
-    throw new Error('Invalid system-prompt lock: selections must be an object');
+  if (lock.selections !== undefined || lock.managedFiles !== undefined) {
+    throw new Error('Invalid system-prompt lock: legacy lock format no longer supported');
   }
-  for (const [category, ids] of Object.entries(lock.selections)) {
-    const config = categories[category];
-    if (!config || !Array.isArray(ids) || ids.some(id => typeof id !== 'string')) {
+  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));
-    if (ids.some(id => !knownIds.has(id))) {
-      throw new Error(`Invalid system-prompt lock: unknown ${category} item`);
+    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');
+        }
+      }
     }
   }
-  if (lock.managedFiles !== undefined) {
-    if (!lock.managedFiles || typeof lock.managedFiles !== 'object' || Array.isArray(lock.managedFiles)) {
-      throw new Error('Invalid system-prompt lock: managedFiles must be an object');
+  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, checksum] of Object.entries(lock.managedFiles)) {
-      if (path.startsWith('/') || path.split('/').includes('..') || !/^[a-f0-9]{64}$/.test(checksum)) {
-        throw new Error('Invalid system-prompt lock: unsafe managed file entry');
+    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');
       }
     }
   }
@@ -152,7 +222,7 @@ async function canWrite(destFile, relativePath, oldLock, force) {
   if (force) return true;
   try {
     const existing = await readFile(destFile);
-    const previousHash = oldLock?.managedFiles?.[relativePath];
+    const previousHash = getExpectedHash(oldLock, relativePath);
     return Boolean(previousHash && previousHash === hash(existing));
   } catch (error) {
     if (error.code === 'ENOENT') return true;
@@ -160,7 +230,7 @@ async function canWrite(destFile, relativePath, oldLock, force) {
   }
 }
 
-async function writeManagedFile(destFile, content, relativePath, options) {
+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(`  ⚠  Preserving existing file: ${relativePath}`);
@@ -169,10 +239,11 @@ async function writeManagedFile(destFile, content, relativePath, options) {
   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) {
+async function copyDir(src, dest, relativeDir, options, owner) {
   if (!options.dryRun) await mkdir(dest, { recursive: true });
   const entries = await readdir(src, { withFileTypes: true });
 
@@ -183,10 +254,10 @@ async function copyDir(src, dest, relativeDir, options) {
     const relativePath = `${relativeDir}/${entry.name}`;
 
     if (entry.isDirectory()) {
-      await copyDir(srcPath, destPath, relativePath, options);
+      await copyDir(srcPath, destPath, relativePath, options, owner);
     } else if (entry.isFile()) {
       const content = await readFile(srcPath);
-      await writeManagedFile(destPath, content, relativePath, options);
+      await writeManagedFile(destPath, content, relativePath, options, owner);
     }
   }
 }
@@ -229,22 +300,22 @@ async function copySelectedDirs(targetDir, category, selectedIds, options) {
   const catConfig = categories[category];
   if (!catConfig || !selectedIds?.length) return;
 
-  const relativeDir = targetSubdir(catConfig.sourceDir);
-  const destParent = resolve(targetDir, relativeDir);
+  const destParent = resolve(targetDir, targetSubdir(catConfig.sourceDir));
 
   for (const id of selectedIds) {
     if (await isRemoved(category, id)) continue;
 
-    const srcPath = resolveSource(`${catConfig.sourceDir}/${id}`);
+    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, `${relativeDir}/${id}`, options);
+      await copyDir(srcPath, destPath, itemRelativePath(category, id), options, { category, id });
     } catch (error) {
       if (sourceMissing(error)) {
-        console.warn(`  ⚠  Source not found: ${catConfig.sourceDir}/${id}`);
+        console.warn(`  ⚠  Source not found: ${source}`);
         continue;
       }
       throw error;
@@ -256,22 +327,22 @@ async function copySelectedFiles(targetDir, category, selectedIds, options) {
   const catConfig = categories[category];
   if (!catConfig || !selectedIds?.length) return;
 
-  const relativeDir = targetSubdir(catConfig.sourceDir);
-  const destParent = resolve(targetDir, relativeDir);
+  const destParent = resolve(targetDir, targetSubdir(catConfig.sourceDir));
   if (!options.dryRun) await mkdir(destParent, { recursive: true });
 
   for (const id of selectedIds) {
     if (await isRemoved(category, id)) continue;
 
-    const srcFile = resolveSource(`${catConfig.sourceDir}/${id}.md`);
-    const destFile = resolve(destParent, `${id}.md`);
+    const source = itemSourcePath(category, id);
+    const relativePath = itemRelativePath(category, id);
+    const destFile = resolve(targetDir, relativePath);
     await assertSafeDestination(targetDir, destFile);
     try {
-      const content = await readFile(srcFile);
-      await writeManagedFile(destFile, content, `${relativeDir}/${id}.md`, options);
+      const content = await readFile(resolveSource(source));
+      await writeManagedFile(destFile, content, relativePath, options, { category, id });
     } catch (error) {
       if (sourceMissing(error)) {
-        console.warn(`  ⚠  Source not found: ${catConfig.sourceDir}/${id}.md`);
+        console.warn(`  ⚠  Source not found: ${source}`);
         continue;
       }
       throw error;
@@ -280,22 +351,14 @@ async function copySelectedFiles(targetDir, category, selectedIds, options) {
 }
 
 async function deleteSelectedItems(absTarget, category, ids, oldLock, force, dryRun) {
-  const catConfig = categories[category];
-  if (!catConfig || !ids?.length) return;
+  if (!categories[category] || !ids?.length || !isCopyable(category)) return;
 
-  const FILE_BASED = new Set(['agents', 'commands', 'memory', 'modes', 'standards', 'templates']);
-  if (!FILE_BASED.has(category) && category !== 'skills' && category !== 'styles') return;
-
-  const relativeDir = targetSubdir(catConfig.sourceDir);
   for (const id of ids) {
-    const relativePath = FILE_BASED.has(category)
-      ? `${relativeDir}/${id}.md`
-      : `${relativeDir}/${id}`;
+    const relativePath = itemRelativePath(category, id);
     const destPath = resolve(absTarget, relativePath);
     await assertSafeDestination(absTarget, destPath);
     if (!force && oldLock) {
-      const managedEntries = Object.entries(oldLock.managedFiles || {})
-        .filter(([path]) => path === relativePath || path.startsWith(`${relativePath}/`));
+      const managedEntries = Object.entries(oldLock?.[category]?.[id]?.files || {});
       if (managedEntries.length === 0) {
         console.warn(`  ⚠  Preserving unmanaged item: ${relativePath}`);
         continue;
@@ -313,7 +376,7 @@ async function deleteSelectedItems(absTarget, category, ids, oldLock, force, dry
         console.warn(`  ⚠  Preserving modified item: ${relativePath}`);
         continue;
       }
-      if (!FILE_BASED.has(category)) {
+      if (!isFileBased(category)) {
         if (!dryRun) {
           for (const [path] of managedEntries) await rm(resolve(absTarget, path), { force: true });
         }
@@ -363,7 +426,7 @@ async function mergeJsonFile(destFile, generated, relativePath, options, previou
   return writeManagedFile(destFile, Buffer.from(JSON.stringify(merged, null, 4)), relativePath, {
     ...options,
     allowExistingMerge: !options.oldLock,
-  });
+  }, { generated: true });
 }
 
 async function mergeGitignore(destFile, options) {
@@ -378,7 +441,7 @@ async function mergeGitignore(destFile, options) {
   return writeManagedFile(destFile, Buffer.from(`${[...lines].join('\n')}\n`), '.gitignore', {
     ...options,
     allowExistingMerge: !options.oldLock,
-  });
+  }, { generated: true });
 }
 
 export function validateSelections(selections) {
@@ -394,7 +457,7 @@ export function validateSelections(selections) {
   return selections;
 }
 
-export async function install({ targetDir, agentType, selections, includeAgentsMd = true, writeAgentsMd, oldSelections, oldLock, force = false, dryRun = false }) {
+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;
@@ -405,8 +468,27 @@ export async function install({ targetDir, agentType, selections, includeAgentsM
     oldLock,
     force,
     dryRun,
-    managedFiles: { ...(oldLock?.managedFiles || {}) },
+    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) {
@@ -419,16 +501,16 @@ export async function install({ targetDir, agentType, selections, includeAgentsM
   }
 
   const tasks = [];
-  for (const category of ['skills', 'styles']) {
-    if (selections[category]?.length) tasks.push(copySelectedDirs(absTarget, category, selections[category], options));
-  }
-  for (const category of ['agents', 'commands', 'modes', 'memory', 'standards', 'templates']) {
-    if (selections[category]?.length) tasks.push(copySelectedFiles(absTarget, category, selections[category], options));
+  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);
+    await writeManagedFile(resolve(absTarget, 'AGENTS.md'), Buffer.from(AGENTS_MD), 'AGENTS.md', options, { generated: true });
   }
 
   if (agentType === 'opencode') {
@@ -437,18 +519,19 @@ export async function install({ targetDir, agentType, selections, includeAgentsM
     let previousOpenCodeConfig;
     let previousTuiConfig;
     if (oldLock) {
+      const oldSelections = lockToSelections(oldLock);
       let previousMcpEntries = {};
-      if (oldLock.selections.mcps?.length) previousMcpEntries = await loadMcpConfigs(oldLock.selections.mcps);
+      if (oldSelections.mcps?.length) previousMcpEntries = await loadMcpConfigs(oldSelections.mcps);
       previousOpenCodeConfig = JSON.parse(generateOpenCodeConfig({
-        selections: oldLock.selections,
+        selections: oldSelections,
         mcpEntries: previousMcpEntries,
         includeAgentsMd: oldLock.includeAgentsMd ?? true,
       }));
-      previousTuiConfig = JSON.parse(generateTuiConfig({ selections: oldLock.selections }));
+      previousTuiConfig = JSON.parse(generateTuiConfig({ selections: oldSelections, 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 })), 'tui.json', options, previousTuiConfig);
+    await mergeJsonFile(resolve(absTarget, 'tui.json'), JSON.parse(generateTuiConfig({ selections, preferences: tuiPreferences })), 'tui.json', options, previousTuiConfig);
     await mergeGitignore(resolve(absTarget, '.gitignore'), options);
   }
 
@@ -458,16 +541,38 @@ export async function install({ targetDir, agentType, selections, includeAgentsM
   }
 
   if (dryRun) return absTarget;
-  const version = await getPackageVersion();
+  const pkgVersion = await getPackageVersion();
+  const source = `system-prompt@${pkgVersion}`;
   const lockData = {
-    version,
+    version: LOCK_VERSION,
     agentType,
-    targetDir,
     installedAt: new Date().toISOString(),
-    selections: Object.fromEntries(Object.entries(selections).map(([k, v]) => [k, [...v]])),
     includeAgentsMd,
-    managedFiles: options.managedFiles,
   };
+  for (const category of LOCK_CATEGORIES) {
+    const entries = {};
+    for (const id of selections[category] || []) {
+      if (await isRemoved(category, id)) continue;
+      const files = {};
+      for (const [path, checksum] of Object.entries(options.managedFiles)) {
+        const owner = options.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(options.managedFiles)) {
+    if (options.fileOwners[path]?.generated) generated[path] = { computedHash: checksum };
+  }
+  lockData.generated = generated;
   await writeFile(resolve(absTarget, 'system-prompt-lock.json'), JSON.stringify(lockData, null, 2));
   return absTarget;
 }
@@ -476,10 +581,6 @@ function resolveSource(subpath) {
   return resolve(packageRoot, subpath);
 }
 
-function targetSubdir(sourceDir) {
-  return sourceDir.replace(/^framework\//, '');
-}
-
 async function isRemoved(category, id) {
   const catConfig = categories[category];
   if (!catConfig) return false;
@@ -548,4 +649,5 @@ async function writeMergedEnv(absTarget, examples, options) {
   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 };
 }

package/src/item-layout.js

@@ -0,0 +1,26 @@
+import { categories } from './catalog.js';
+
+export const LOCK_CATEGORIES = Object.keys(categories);
+
+export function isFileBased(category) {
+  return categories[category]?.itemLayout === 'file';
+}
+
+export function isCopyable(category) {
+  const config = categories[category];
+  return Boolean(config?.itemLayout) && config.copyItems !== false;
+}
+
+export function targetSubdir(sourceDir) {
+  return sourceDir.replace(/^framework\//, '');
+}
+
+export function itemSourcePath(category, id) {
+  const config = categories[category];
+  return isFileBased(category) ? `${config.sourceDir}/${id}.md` : `${config.sourceDir}/${id}`;
+}
+
+export function itemRelativePath(category, id) {
+  const dir = targetSubdir(categories[category].sourceDir);
+  return isFileBased(category) ? `${dir}/${id}.md` : `${dir}/${id}`;
+}