@mohammadhprp/system-prompt 0.10.1

package/src/catalog.js

@@ -0,0 +1,145 @@
+export const categories = {
+  skills: {
+    title: 'Skills',
+    description: 'Task-specific procedures for AI coding agents',
+    sourceDir: 'framework/skills',
+    items: [
+      { id: 'agent-browser', name: 'Agent Browser', description: 'Automate browser and Electron workflows for navigation, testing, screenshots, and data extraction' },
+      { id: 'backend-best-practices', name: 'Backend Best Practices', description: 'Consolidated backend engineering practices across API, data, security, testing, and operations' },
+      { id: 'backend-engineer', name: 'Backend Engineer', description: 'Analyze backend requirements, risks, and implementation plans' },
+      { id: 'brainstorming', name: 'Brainstorming', description: 'Turn ideas into fully formed designs through dialogue' },
+      { id: 'brand-guidelines', name: 'Brand Guidelines', description: 'Apply official brand colors and typography' },
+      { id: 'code-review', name: 'Code Review', description: 'Review backend changes for correctness and maintainability' },
+      { id: 'design', name: 'Design Like Damien', description: 'Premium UI design philosophy and Lovable prompting' },
+      { id: 'diagram-design', name: 'Diagram Design', description: 'Create technical and product diagrams as standalone HTML with inline SVG' },
+      { id: 'documentation', name: 'Documentation', description: 'Create ADRs, design docs, runbooks, and API docs' },
+      { id: 'find-skills', name: 'Find Skills', description: 'Discover, evaluate, and install agent skills for specialized tasks' },
+      { id: 'gitlab-mcp', name: 'GitLab MCP', description: 'Work with GitLab via MCP for MRs, issues, pipelines' },
+      { id: 'jira-mcp', name: 'Jira MCP', description: 'Work with Jira MCP for issue management and JQL search' },
+      { id: 'laravel-best-practices', name: 'Laravel Best Practices', description: 'Laravel patterns for Eloquent, validation, testing' },
+      { id: 'lavish', name: 'Lavish', description: 'Turn complex responses into rich HTML artifacts' },
+      { id: 'notion-mcp', name: 'Notion MCP', description: 'Work with Notion MCP for pages, databases, search' },
+      { id: 'skill-creator', name: 'Skill Creator', description: 'Create and evaluate new agent skills' }
+    ],
+  },
+
+  agents: {
+    title: 'Subagents',
+    description: 'Specialized subagents for security, architecture, review, and research',
+    sourceDir: 'framework/agents',
+    items: [
+      { id: 'backend-architect', name: 'Backend Architect', description: 'Design scalable, secure backend systems' },
+      { id: 'researcher', name: 'Researcher', description: 'Fetch and analyze web content from URLs' },
+      { id: 'reviewer', name: 'Reviewer', description: 'Review code for correctness and best practices' },
+      { id: 'security-auditor', name: 'Security Auditor', description: 'Conduct security audits for REST APIs' },
+    ],
+  },
+
+  commands: {
+    title: 'Slash Commands',
+    description: 'Slash command workflows for repeatable tasks',
+    sourceDir: 'framework/commands',
+    items: [
+      { id: 'changelog', name: 'Changelog', description: 'Create, add, or update CHANGELOG.md entries' },
+      { id: 'commit', name: 'Commit', description: 'Create atomic git commits with conventional messages' },
+      { id: 'learn', name: 'Learn', description: 'Distill a reusable skill from any source' },
+      { id: 'pr', name: 'PR', description: 'Create a GitHub PR for the current branch' },
+      { id: 'mr', name: 'MR', description: 'Create a GitLab MR for the current branch' },
+      { id: 'release', name: 'Release', description: 'Tag releases, update changelog, and bump versions' },
+      { id: 'review', name: 'Review', description: 'Perform comprehensive code quality review' },
+      { id: 'summarize-changes', name: 'Summarize Changes', description: 'Summarize uncommitted changes and flag risks' },
+    ],
+  },
+
+  mcps: {
+    title: 'MCPs',
+    description: 'Model Context Protocol servers for AI coding agents',
+    sourceDir: 'framework/mcps',
+    items: [
+      { id: 'excalidraw', name: 'Excalidraw MCP', description: 'Stream hand-drawn diagrams with interactive editing' },
+      { id: 'figma-mcp-go', name: 'Figma MCP Go', description: 'Read/write access to Figma designs via plugin bridge' },
+      { id: 'gitlab-mcp', name: 'GitLab MCP', description: 'Comprehensive GitLab integration' },
+      { id: 'github-mcp', name: 'GitHub MCP', description: 'Browse repos, manage issues/PRs, monitor Actions' },
+      { id: 'jira-mcp', name: 'Jira MCP', description: 'Interact with self-hosted Jira instances' },
+      { id: 'laravel-boost', name: 'Laravel Boost MCP', description: 'Laravel application context and ecosystem docs' },
+      { id: 'notion-mcp', name: 'Notion MCP', description: 'Search, read, and write Notion content' },
+      { id: 'playwright-mcp', name: 'Playwright MCP', description: 'Cross-browser automation with accessibility snapshots' },
+      { id: 'supabase-mcp', name: 'Supabase MCP', description: 'Manage Supabase projects, SQL, Edge Functions, Auth, Storage, and Realtime' },
+    ],
+  },
+
+  plugins: {
+    title: 'Plugins',
+    description: 'OpenCode plugins that extend the core agent',
+    sourceDir: 'framework/plugins',
+    items: [
+      { id: 'opencode-goal-plugin', name: 'OpenCode Goal Plugin', description: 'Goal-driven long-running tasks with persistence' },
+      { id: 'ponytail', name: 'Ponytail', description: 'Lazy senior dev mode — YAGNI-first, reuse-first ladder that reduces code bloat and cost' },
+    ],
+  },
+
+  styles: {
+    title: 'Styles',
+    description: 'Design system references from Refero Styles',
+    sourceDir: 'framework/styles',
+    items: [
+      { id: 'linear', name: 'Linear', description: 'Midnight precision instrument design system' },
+      { id: 'raycast', name: 'Raycast', description: 'Midnight command center design system' },
+    ],
+  },
+
+  modes: {
+    title: 'Modes',
+    description: 'Behavior, tool, and prompt presets for different use cases',
+    sourceDir: 'framework/modes',
+    items: [
+      { id: 'audit', name: 'Audit', description: 'Read-only high-scrutiny review mode for evaluating artifacts' },
+    ],
+  },
+
+  memory: {
+    title: 'Memory',
+    description: 'Persistent agent memory files for cross-session context',
+    sourceDir: 'framework/memory',
+    items: [
+      { id: 'codebase-insights', name: 'Codebase Insights', description: 'Non-obvious facts, gotchas, past decisions, and architecture quirks' },
+      { id: 'user-preferences', name: 'User Preferences', description: 'Coding style, naming conventions, and architectural preferences' },
+    ],
+  },
+
+  standards: {
+    title: 'Standards',
+    description: 'Canonical engineering standards',
+    sourceDir: 'framework/references/standards',
+    items: [
+      { id: 'api', name: 'API Design', description: 'REST API design standards' },
+      { id: 'architecture', name: 'Architecture', description: 'System architecture standards' },
+      { id: 'database', name: 'Database', description: 'Database design standards' },
+      { id: 'debugging', name: 'Debugging', description: 'Debugging methodology' },
+      { id: 'documentation', name: 'Documentation', description: 'Documentation standards' },
+      { id: 'logging', name: 'Logging', description: 'Logging standards' },
+      { id: 'naming', name: 'Naming', description: 'Naming conventions' },
+      { id: 'observability', name: 'Observability', description: 'Observability standards' },
+      { id: 'performance', name: 'Performance', description: 'Performance standards' },
+      { id: 'pull-requests', name: 'Pull Requests', description: 'Pull request standards' },
+      { id: 'security', name: 'Security', description: 'Security standards' },
+      { id: 'testing', name: 'Testing', description: 'Testing standards' },
+    ],
+  },
+
+  templates: {
+    title: 'Templates',
+    description: 'Fillable workflow documents',
+    sourceDir: 'framework/references/templates',
+    items: [
+      { id: 'adr', name: 'ADR', description: 'Architecture Decision Record' },
+      { id: 'api-spec', name: 'API Spec', description: 'API specification document' },
+      { id: 'design-document', name: 'Design Document', description: 'Design document template' },
+      { id: 'incident-report', name: 'Incident Report', description: 'Incident report template' },
+      { id: 'postmortem', name: 'Postmortem', description: 'Postmortem template' },
+      { id: 'pull-request', name: 'Pull Request', description: 'Pull request template' },
+      { id: 'runbook', name: 'Runbook', description: 'Runbook template' },
+      { id: 'task', name: 'Task', description: 'Task template' },
+    ],
+  },
+};

package/src/cli.js

@@ -0,0 +1,254 @@
+import { intro, outro, confirm, multiselect, spinner, isCancel } from '@clack/prompts';
+import { resolve } from 'node:path';
+
+import { categories } from './catalog.js';
+import { getPackageVersion, install, loadLockFile } from './installer.js';
+
+function buildSummary(selections) {
+  const lines = [];
+  for (const [cat, ids] of Object.entries(selections)) {
+    if (!ids?.length) continue;
+    const catConfig = categories[cat];
+    const label = catConfig?.title || cat;
+    const names = ids.map(id => {
+      const item = catConfig?.items.find(i => i.id === id);
+      return item ? item.name : id;
+    });
+    lines.push(`  ${label}: ${names.join(', ')}`);
+  }
+  return lines.join('\n');
+}
+
+function computeDiff(oldLock, selections) {
+  const oldSels = oldLock.selections;
+  const added = {};
+  const removed = {};
+  const kept = {};
+
+  const allCats = [...new Set([...Object.keys(oldSels), ...Object.keys(selections)])];
+
+  for (const cat of allCats) {
+    const catConfig = categories[cat] || null;
+    const oldIds = new Set(oldSels[cat] || []);
+    const newIds = new Set(selections[cat] || []);
+
+    const addedIds = [...newIds].filter(id => !oldIds.has(id));
+    const removedIds = [...oldIds].filter(id => !newIds.has(id));
+    const keptIds = [...newIds].filter(id => oldIds.has(id));
+
+    if (addedIds.length) added[cat] = { config: catConfig, ids: addedIds };
+    if (removedIds.length) removed[cat] = { config: catConfig, ids: removedIds };
+    if (keptIds.length) kept[cat] = { config: catConfig, ids: keptIds };
+  }
+
+  return { added, removed, kept };
+}
+
+function formatDiff(diff) {
+  const { added, removed, kept } = diff;
+  const lines = [];
+
+  if (Object.keys(added).length) {
+    lines.push('  + Added:');
+    for (const [cat, data] of Object.entries(added)) {
+      const names = data.ids.map(id => {
+        const item = data.config?.items?.find(i => i.id === id);
+        return item?.name || id;
+      });
+      lines.push(`    ${data.config?.title || cat}: ${names.join(', ')}`);
+    }
+  }
+
+  if (Object.keys(removed).length) {
+    if (lines.length) lines.push('');
+    lines.push('  - Removed:');
+    for (const [cat, data] of Object.entries(removed)) {
+      const names = data.ids.map(id => {
+        const item = data.config?.items?.find(i => i.id === id);
+        return item?.name || id;
+      });
+      lines.push(`    ${data.config?.title || cat}: ${names.join(', ')}`);
+    }
+  }
+
+  if (Object.keys(kept).length) {
+    if (lines.length) lines.push('');
+    lines.push('  ~ Unchanged:');
+    for (const [cat, data] of Object.entries(kept)) {
+      const names = data.ids.map(id => {
+        const item = data.config?.items?.find(i => i.id === id);
+        return item?.name || id;
+      });
+      lines.push(`    ${data.config?.title || cat}: ${names.join(', ')}`);
+    }
+  }
+
+  return lines.join('\n');
+}
+
+export async function main() {
+  const version = await getPackageVersion();
+  intro(`System prompt (v${version})`);
+
+  const agentType = 'opencode';
+  const targetDir = '.opencode';
+
+  const categoryOptions = Object.entries(categories).map(([key, cat]) => {
+    const visible = cat.items.filter(i => !i.removed);
+    return {
+      value: key,
+      label: cat.title,
+      hint: `${visible.length} ${key === 'mcps' ? 'MCPs' : cat.title.toLowerCase()}`,
+    };
+  });
+
+  const selectedCategories = await multiselect({
+    message: 'What would you like to install?',
+    options: categoryOptions,
+    required: false,
+  });
+  if (isCancel(selectedCategories)) {
+    outro('Cancelled.');
+    process.exit(0);
+  }
+
+  if (!selectedCategories?.length) {
+    const includeAgentsMd = await confirm({
+      message: 'Generate AGENTS.md?',
+      initialValue: true,
+    });
+    if (isCancel(includeAgentsMd)) {
+      outro('Cancelled.');
+      process.exit(0);
+    }
+
+    const s = spinner();
+    s.start('Writing files...');
+    await install({
+       targetDir,
+      agentType,
+      selections: {},
+      includeAgentsMd,
+    });
+    s.stop('Done.');
+    const installed = [];
+    if (includeAgentsMd) installed.push('AGENTS.md');
+    outro(`${installed.join(' and ')} written. Open them in your project to get started.`);
+    process.exit(0);
+  }
+
+  const selections = {};
+
+  const includeAgentsMd = await confirm({
+    message: 'Generate AGENTS.md?',
+    initialValue: true,
+  });
+  if (isCancel(includeAgentsMd)) {
+    outro('Cancelled.');
+    process.exit(0);
+  }
+
+  for (const cat of selectedCategories) {
+    const catConfig = categories[cat];
+    const allIds = catConfig.items.map(i => i.id);
+
+      const visibleItems = catConfig.items.filter(i => !i.removed);
+
+      const all = await confirm({
+        message: `Install all ${catConfig.title.toLowerCase()}?`,
+        initialValue: visibleItems.length <= 12,
+      });
+      if (isCancel(all)) {
+        outro('Cancelled.');
+        process.exit(0);
+      }
+
+      if (all) {
+        selections[cat] = visibleItems.map(i => i.id);
+      } else {
+        const picked = await multiselect({
+          message: `Which ${catConfig.title.toLowerCase()} do you want?`,
+          options: visibleItems.map(item => ({
+            value: item.id,
+            label: item.deprecated ? `${item.name} (deprecated)` : item.name,
+            hint: item.deprecated ? '⚠  Deprecated — consider alternatives' : item.description,
+          })),
+          required: true,
+        });
+      if (isCancel(picked)) {
+        outro('Cancelled.');
+        process.exit(0);
+      }
+      selections[cat] = picked;
+    }
+  }
+
+  const absTarget = resolve(process.cwd(), targetDir);
+  const oldLock = await loadLockFile(absTarget);
+
+  if (oldLock) {
+    const diff = computeDiff(oldLock, selections);
+    const diffText = formatDiff(diff);
+
+    console.log('\n📦 Changes from previous installation:\n');
+    if (diffText) {
+      console.log(diffText);
+      console.log();
+    } else {
+      console.log('  No changes — same selections as before.\n');
+    }
+
+    const genFiles = [];
+    if (includeAgentsMd) genFiles.push('AGENTS.md');
+    genFiles.push('opencode.json', 'tui.json', '.gitignore');
+    if (selections.mcps?.length) genFiles.push('.env');
+    if (selections.memory?.length) genFiles.push('memory/');
+
+    if (genFiles.length) {
+      console.log('  Generated files:');
+      for (const f of genFiles) {
+        console.log(`    📄 ${f}`);
+      }
+      console.log();
+    }
+  } else {
+    console.log('\n📦 Summary of what will be installed:\n');
+    if (includeAgentsMd) console.log('  📄 AGENTS.md');
+    console.log('  📄 opencode.json');
+    console.log('  📄 tui.json');
+    console.log('  📄 .gitignore');
+    console.log(buildSummary(selections));
+    console.log();
+  }
+
+  const confirmed = await confirm({
+    message: 'Proceed with installation?',
+    initialValue: true,
+  });
+  if (isCancel(confirmed) || !confirmed) {
+    outro('Installation cancelled.');
+    process.exit(0);
+  }
+
+  const s = spinner();
+  s.start(oldLock ? 'Updating files...' : 'Installing files...');
+
+  const finalTarget = await install({
+    targetDir,
+    agentType,
+    selections,
+    includeAgentsMd,
+    oldSelections: oldLock?.selections,
+  });
+
+  s.stop('Installation complete!');
+
+  const fileCount = Object.values(selections).reduce((sum, arr) => sum + (arr?.length || 0), 0);
+  const verb = oldLock ? 'Updated' : 'Installed';
+  outro(`${verb} ${fileCount} components to ${finalTarget}
+
+Next steps:
+  ${agentType === 'opencode' ? '- Open your project in OpenCode — it will read opencode.json and AGENTS.md automatically' : '- Point your AI coding agent to AGENTS.md as the entry point'}
+  - Run /help in your agent to see available commands
+`);
+}

package/src/installer.js

@@ -0,0 +1,303 @@
+import { fileURLToPath } from 'node:url';
+import { dirname, resolve } from 'node:path';
+import { mkdir, copyFile, writeFile, readdir, stat, readFile, rm } from 'node:fs/promises';
+
+import { categories } from './catalog.js';
+import { loadMcpConfigs, generateOpenCodeConfig, generateTuiConfig } from './agent-configs.js';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const packageRoot = resolve(__dirname, '..');
+
+const AGENTS_MD = `# AGENTS.md
+
+> Fill this base on project use /init command
+`;
+
+const OPENCODE_GITIGNORE = `.env*
+node_modules
+package.json
+package-lock.json
+bun.lock
+`;
+
+export async function getPackageVersion() {
+  try {
+    const pkg = JSON.parse(await readFile(resolve(packageRoot, 'package.json'), 'utf-8'));
+    return pkg.version || '0.0.0';
+  } catch {
+    return '0.0.0';
+  }
+}
+
+export async function loadLockFile(absTarget) {
+  try {
+    const content = await readFile(resolve(absTarget, 'system-prompt-lock.json'), 'utf-8');
+    return JSON.parse(content);
+  } catch {
+    return null;
+  }
+}
+
+function resolveSource(subpath) {
+  return resolve(packageRoot, subpath);
+}
+
+function targetSubdir(sourceDir) {
+  return sourceDir.replace(/^framework\//, '');
+}
+
+async function copyDir(src, dest) {
+  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);
+
+    if (entry.isDirectory()) {
+      await copyDir(srcPath, destPath);
+    } else if (entry.isFile()) {
+      await mkdir(dirname(destPath), { recursive: true });
+      await copyFile(srcPath, destPath);
+    }
+  }
+}
+
+async function isRemoved(category, id) {
+  const catConfig = categories[category];
+  if (!catConfig) return false;
+  const item = catConfig.items.find(i => i.id === id);
+  return item?.removed === true;
+}
+
+async function copySelectedDirs(targetDir, category, selectedIds) {
+  const catConfig = categories[category];
+  if (!catConfig || !selectedIds?.length) return;
+
+  const relativeDir = targetSubdir(catConfig.sourceDir);
+  const destParent = resolve(targetDir, relativeDir);
+
+  for (const id of selectedIds) {
+    if (await isRemoved(category, id)) continue;
+
+    const srcPath = resolveSource(`${catConfig.sourceDir}/${id}`);
+    const destPath = resolve(destParent, id);
+
+    try {
+      await stat(srcPath);
+      await copyDir(srcPath, destPath);
+    } catch {
+      console.warn(`  ⚠  Source not found: ${catConfig.sourceDir}/${id}`);
+    }
+  }
+}
+
+async function copySelectedFiles(targetDir, category, selectedIds, skipIfExists = false) {
+  const catConfig = categories[category];
+  if (!catConfig || !selectedIds?.length) return;
+
+  const relativeDir = targetSubdir(catConfig.sourceDir);
+  const destParent = resolve(targetDir, relativeDir);
+  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`);
+    try {
+      await stat(srcFile);
+      if (skipIfExists) {
+        try {
+          await stat(destFile);
+          continue;
+        } catch {
+          // dest doesn't exist — proceed to copy
+        }
+      }
+      await copyFile(srcFile, destFile);
+    } catch {
+      console.warn(`  ⚠  Source not found: ${catConfig.sourceDir}/${id}.md`);
+    }
+  }
+}
+
+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;
+}
+
+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 {
+      // Silently skip MCPs without .env.example
+    }
+  }
+  return combined;
+}
+
+async function deleteSelectedItems(absTarget, category, ids) {
+  const catConfig = categories[category];
+  if (!catConfig || !ids?.length) 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);
+  const destParent = resolve(absTarget, relativeDir);
+
+  for (const id of ids) {
+    const destPath = FILE_BASED.has(category)
+      ? resolve(destParent, `${id}.md`)
+      : resolve(destParent, id);
+    try {
+      await rm(destPath, { recursive: true, force: true });
+    } catch {
+      // File may not exist — ignore
+    }
+  }
+}
+
+async function writeMergedEnv(absTarget, examples) {
+  if (examples.size === 0) return;
+
+  const envPath = resolve(absTarget, '.env');
+  const existing = new Map();
+
+  try {
+    const existingContent = await readFile(envPath, 'utf-8');
+    const parsed = parseEnv(existingContent);
+    for (const [key, value] of parsed) existing.set(key, value);
+  } catch {
+    // File doesn't exist yet
+  }
+
+  const merged = new Map(existing);
+  for (const [key, value] of examples) {
+    if (!merged.has(key)) merged.set(key, value);
+  }
+
+  if (merged.size === 0) return;
+
+  const lines = [];
+  for (const [key, value] of merged) {
+    lines.push(`${key}=${value}`);
+  }
+  lines.push('');
+
+  await writeFile(envPath, lines.join('\n'));
+}
+
+function generateAgentsMd({ selections }) {
+  return AGENTS_MD;
+}
+
+export async function install({ targetDir, agentType, selections, includeAgentsMd = true, writeAgentsMd, oldSelections }) {
+  writeAgentsMd = writeAgentsMd ?? includeAgentsMd;
+  const absTarget = resolve(process.cwd(), targetDir);
+  await mkdir(absTarget, { recursive: 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));
+      if (removedIds.length > 0) {
+        await deleteSelectedItems(absTarget, cat, removedIds);
+      }
+    }
+  }
+
+  const tasks = [];
+
+  if (selections.skills?.length) {
+    tasks.push(copySelectedDirs(absTarget, 'skills', selections.skills));
+  }
+  if (selections.agents?.length) {
+    tasks.push(copySelectedFiles(absTarget, 'agents', selections.agents));
+  }
+  if (selections.commands?.length) {
+    tasks.push(copySelectedFiles(absTarget, 'commands', selections.commands));
+  }
+  if (selections.styles?.length) {
+    tasks.push(copySelectedDirs(absTarget, 'styles', selections.styles));
+  }
+  if (selections.modes?.length) {
+    tasks.push(copySelectedFiles(absTarget, 'modes', selections.modes));
+  }
+  if (selections.memory?.length) {
+    tasks.push(copySelectedFiles(absTarget, 'memory', selections.memory, true));
+  }
+  if (selections.standards?.length) {
+    tasks.push(copySelectedFiles(absTarget, 'standards', selections.standards));
+  }
+  if (selections.templates?.length) {
+    tasks.push(copySelectedFiles(absTarget, 'templates', selections.templates));
+  }
+
+  await Promise.all(tasks);
+
+  if (writeAgentsMd) {
+    const agentsContent = generateAgentsMd({ selections });
+    await writeFile(resolve(absTarget, 'AGENTS.md'), agentsContent);
+  }
+
+  if (agentType === 'opencode') {
+    let mcpEntries = {};
+    if (selections.mcps?.length) {
+      mcpEntries = await loadMcpConfigs(selections.mcps);
+    }
+    const configJson = generateOpenCodeConfig({
+      selections,
+      mcpEntries,
+      includeAgentsMd: includeAgentsMd,
+    });
+    if (configJson) {
+      await writeFile(resolve(absTarget, 'opencode.json'), configJson);
+    }
+    await writeFile(resolve(absTarget, 'tui.json'), generateTuiConfig({ selections }));
+    await writeFile(resolve(absTarget, '.gitignore'), OPENCODE_GITIGNORE);
+  }
+
+  if (selections.mcps?.length) {
+    const envExamples = await collectMcpEnvExamples(selections.mcps);
+    await writeMergedEnv(absTarget, envExamples);
+  }
+
+  const version = await getPackageVersion();
+  const lockData = {
+    version,
+    agentType,
+    targetDir,
+    installedAt: new Date().toISOString(),
+    selections: Object.fromEntries(
+      Object.entries(selections).map(([k, v]) => [k, [...v]])
+    ),
+    includeAgentsMd,
+  };
+  await writeFile(resolve(absTarget, 'system-prompt-lock.json'), JSON.stringify(lockData, null, 2));
+
+  return absTarget;
+}