@mohammadhprp/system-prompt 0.13.0 → 0.13.2

package/src/cli/tui-preferences.js

@@ -0,0 +1,118 @@
+import { readFile } from 'node:fs/promises';
+import { resolve } from 'node:path';
+
+import { normalizeTuiPreferences, TUI_THEMES, tuiPreferencesFromConfig } from '../config/tui.js';
+
+export async function readTuiPreferences(absTarget) {
+  try {
+    return tuiPreferencesFromConfig(JSON.parse(await readFile(resolve(absTarget, 'tui.json'), 'utf-8')));
+  } catch (error) {
+    if (error.code === 'ENOENT' || error instanceof SyntaxError) return {};
+    throw error;
+  }
+}
+
+export async function collectTuiPreferences(existing, ui) {
+  const base = normalizeTuiPreferences(existing);
+
+  const theme = await ui.select({
+    message: 'TUI theme',
+    options: TUI_THEMES.map(value => ({
+      value,
+      label: value,
+      hint: value === 'system' ? 'Adapts to your terminal' : undefined,
+    })),
+    initialValue: base.theme,
+  });
+  if (ui.isCancel(theme)) return null;
+
+  const diffStyle = await ui.select({
+    message: 'Diff style',
+    options: [
+      { value: 'auto', label: 'auto', hint: 'Adapts to terminal width' },
+      { value: 'stacked', label: 'stacked', hint: 'Always single column' },
+    ],
+    initialValue: base.diff_style,
+  });
+  if (ui.isCancel(diffStyle)) return null;
+
+  const cursorStyle = await ui.select({
+    message: 'Cursor style',
+    options: ['block', 'underline', 'line', 'default'].map(value => ({ value, label: value })),
+    initialValue: base.cursor.style,
+  });
+  if (ui.isCancel(cursorStyle)) return null;
+
+  const scrollSpeed = await ui.select({
+    message: 'Scroll speed',
+    options: [
+      { value: 1, label: '1', hint: 'Slow' },
+      { value: 2, label: '2' },
+      { value: 3, label: '3', hint: 'Default' },
+      { value: 4, label: '4' },
+      { value: 5, label: '5', hint: 'Fast' },
+    ],
+    initialValue: base.scroll_speed,
+  });
+  if (ui.isCancel(scrollSpeed)) return null;
+
+  const scrollAcceleration = await ui.confirm({
+    message: 'Enable scroll acceleration?',
+    initialValue: base.scroll_acceleration,
+  });
+  if (ui.isCancel(scrollAcceleration)) return null;
+
+  const mouse = await ui.confirm({
+    message: 'Enable mouse support?',
+    initialValue: base.mouse,
+  });
+  if (ui.isCancel(mouse)) return null;
+
+  const attentionEnabled = await ui.confirm({
+    message: 'Enable attention notifications and sounds?',
+    initialValue: base.attention.enabled,
+  });
+  if (ui.isCancel(attentionEnabled)) return null;
+
+  const attention = { ...base.attention, enabled: attentionEnabled };
+  if (attentionEnabled) {
+    const notifications = await ui.confirm({
+      message: 'Desktop notifications?',
+      initialValue: base.attention.notifications,
+    });
+    if (ui.isCancel(notifications)) return null;
+
+    const sound = await ui.confirm({
+      message: 'Sound alerts?',
+      initialValue: base.attention.sound,
+    });
+    if (ui.isCancel(sound)) return null;
+
+    const volume = await ui.select({
+      message: 'Alert volume',
+      options: [
+        { value: 0.2, label: '20%' },
+        { value: 0.4, label: '40%', hint: 'Default' },
+        { value: 0.6, label: '60%' },
+        { value: 0.8, label: '80%' },
+        { value: 1, label: '100%' },
+      ],
+      initialValue: base.attention.volume,
+    });
+    if (ui.isCancel(volume)) return null;
+
+    attention.notifications = notifications;
+    attention.sound = sound;
+    attention.volume = volume;
+  }
+
+  return normalizeTuiPreferences({
+    theme,
+    diff_style: diffStyle,
+    cursor: { style: cursorStyle, blinking: base.cursor.blinking },
+    scroll_speed: scrollSpeed,
+    scroll_acceleration: scrollAcceleration,
+    mouse,
+    attention,
+  });
+}

package/src/config/mcp.js

@@ -0,0 +1,25 @@
+import { readFile } from 'node:fs/promises';
+
+import { isMissing, resolveSource } from '../paths.js';
+import { status } from '../ui.js';
+
+export async function loadMcpConfigs(selectedIds) {
+  const entries = {};
+  for (const id of selectedIds) {
+    try {
+      const configPath = resolveSource(`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 (isMissing(error)) {
+        console.warn(status('warn', `No opencode.json config found for MCP: ${id}`));
+        continue;
+      }
+      throw error;
+    }
+  }
+  return entries;
+}

package/src/config/opencode.js

@@ -0,0 +1,47 @@
+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);
+}

package/src/config/tui.js

@@ -0,0 +1,92 @@
+export const TUI_THEMES = [
+  'system',
+  'tokyonight',
+  'everforest',
+  'ayu',
+  'catppuccin',
+  'catppuccin-macchiato',
+  'gruvbox',
+  'kanagawa',
+  'nord',
+  'matrix',
+  'one-dark',
+];
+
+export const TUI_DEFAULTS = {
+  theme: 'system',
+  scroll_speed: 3,
+  scroll_acceleration: true,
+  diff_style: 'auto',
+  mouse: true,
+  cursor: { style: 'block', blinking: true },
+  attention: { enabled: true, notifications: true, sound: true, volume: 0.4 },
+};
+
+export function normalizeTuiPreferences(preferences = {}) {
+  const source = preferences || {};
+  const cursor = source.cursor || {};
+  const attention = source.attention || {};
+  const scrollSpeed = Number(source.scroll_speed);
+  const volume = Number(attention.volume);
+
+  return {
+    theme: typeof source.theme === 'string' && source.theme ? source.theme : TUI_DEFAULTS.theme,
+    scroll_speed: Number.isFinite(scrollSpeed) && scrollSpeed >= 0.001 ? scrollSpeed : TUI_DEFAULTS.scroll_speed,
+    scroll_acceleration: typeof source.scroll_acceleration === 'boolean' ? source.scroll_acceleration : TUI_DEFAULTS.scroll_acceleration,
+    diff_style: source.diff_style === 'stacked' ? 'stacked' : 'auto',
+    mouse: typeof source.mouse === 'boolean' ? source.mouse : TUI_DEFAULTS.mouse,
+    cursor: {
+      style: ['block', 'underline', 'line', 'default'].includes(cursor.style) ? cursor.style : TUI_DEFAULTS.cursor.style,
+      blinking: typeof cursor.blinking === 'boolean' ? cursor.blinking : TUI_DEFAULTS.cursor.blinking,
+    },
+    attention: {
+      enabled: typeof attention.enabled === 'boolean' ? attention.enabled : TUI_DEFAULTS.attention.enabled,
+      notifications: typeof attention.notifications === 'boolean' ? attention.notifications : TUI_DEFAULTS.attention.notifications,
+      sound: typeof attention.sound === 'boolean' ? attention.sound : TUI_DEFAULTS.attention.sound,
+      volume: Number.isFinite(volume) && volume >= 0 && volume <= 1 ? volume : TUI_DEFAULTS.attention.volume,
+    },
+  };
+}
+
+export function tuiPreferencesFromConfig(config) {
+  if (!config || typeof config !== 'object') return {};
+  const preferences = {};
+  if (typeof config.theme === 'string') preferences.theme = config.theme;
+  if (typeof config.scroll_speed === 'number') preferences.scroll_speed = config.scroll_speed;
+  if (typeof config.scroll_acceleration?.enabled === 'boolean') preferences.scroll_acceleration = config.scroll_acceleration.enabled;
+  if (typeof config.diff_style === 'string') preferences.diff_style = config.diff_style;
+  if (typeof config.mouse === 'boolean') preferences.mouse = config.mouse;
+  if (config.cursor && typeof config.cursor === 'object') preferences.cursor = config.cursor;
+  if (config.attention && typeof config.attention === 'object') preferences.attention = config.attention;
+  return preferences;
+}
+
+export function generateTuiConfig({ selections, preferences }) {
+  const prefs = normalizeTuiPreferences(preferences);
+  const config = {
+    $schema: 'https://opencode.ai/tui.json',
+    theme: prefs.theme,
+    scroll_speed: prefs.scroll_speed,
+    scroll_acceleration: {
+      enabled: prefs.scroll_acceleration,
+    },
+    diff_style: prefs.diff_style,
+    cursor: {
+      style: prefs.cursor.style,
+      blinking: prefs.cursor.blinking,
+    },
+    mouse: prefs.mouse,
+    attention: {
+      enabled: prefs.attention.enabled,
+      notifications: prefs.attention.notifications,
+      sound: prefs.attention.sound,
+      volume: prefs.attention.volume,
+    },
+  };
+
+  if (selections.plugins?.includes('opencode-goal-plugin')) {
+    config.plugin = ['@prevalentware/opencode-goal-plugin'];
+  }
+
+  return JSON.stringify(config, null, 4);
+}

package/src/doctor.js

@@ -1,9 +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 {
@@ -14,6 +17,16 @@ async function exists(path) {
   }
 }
 
+async function checkManagedFile(absTarget, relativePath, expectedHash, issues) {
+  try {
+    const actual = hash(await readFile(resolve(absTarget, relativePath)));
+    if (actual !== expectedHash) issues.push(`Modified managed file: ${relativePath}`);
+  } catch (error) {
+    if (isMissing(error)) issues.push(`Missing managed file: ${relativePath}`);
+    else throw error;
+  }
+}
+
 export async function inspectInstallation(targetDir) {
   const absTarget = resolve(process.cwd(), targetDir);
   const issues = [];
@@ -32,26 +45,14 @@ export async function inspectInstallation(targetDir) {
   }
 
   for (const [path, entry] of Object.entries(lock.generated || {})) {
-    try {
-      const actual = createHash('sha256').update(await readFile(resolve(absTarget, path))).digest('hex');
-      if (actual !== entry.computedHash) issues.push(`Modified managed file: ${path}`);
-    } catch (error) {
-      if (error.code === 'ENOENT') issues.push(`Missing managed file: ${path}`);
-      else throw error;
-    }
+    await checkManagedFile(absTarget, path, entry.computedHash, issues);
   }
 
   for (const [category, entries] of Object.entries(lock)) {
     if (!categories[category]) continue;
-    for (const [id, entry] of Object.entries(entries)) {
+    for (const entry of Object.values(entries)) {
       for (const [path, expected] of Object.entries(entry.files || {})) {
-        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;
-        }
+        await checkManagedFile(absTarget, path, expected, issues);
       }
     }
   }
@@ -60,10 +61,7 @@ export async function inspectInstallation(targetDir) {
     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}`);
       }
     }
@@ -89,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 });
+  }
+}