@mohammadhprp/system-prompt 0.13.0 → 0.13.2

package/bin/system-prompt.js

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 
-import { main } from '../src/cli.js';
+import { main } from '../src/cli/index.js';
 
 main().catch((err) => {
   console.error('Fatal error:', err);

package/framework/skills/README.md

@@ -21,6 +21,7 @@ This catalog is framework-agnostic: each skill defines when to activate, a step-
 | [effective-html](./effective-html/SKILL.md) | Create self-contained HTML artifacts with routed guidance for design, wireframes, prototypes, plans, and diagrams. | Standalone HTML reports, explainers, interfaces, wireframes, prototypes, plans, and diagrams. |
 | [find-skills](./find-skills/SKILL.md) | Discover, evaluate, and install skills from the open agent skills ecosystem. | Finding an installable skill for a specialized task or extending an agent's capabilities. |
 | [frontend-design](./frontend-design/SKILL.md) | Distinctive, intentional visual design for new UI or reshaping existing UI — aesthetic direction, typography, and choices that don't read as templated defaults. | Building new interfaces, reshaping existing UI, or escaping generic AI-generated design looks. |
+| [grilling](./grilling/SKILL.md) | Grill plans and decisions relentlessly through design-tree rounds until shared understanding is reached. | Stress-testing ideas, surfacing hidden assumptions, and scoping plans before implementation. |
 | [glab](./glab/SKILL.md) | Use the GitLab CLI (glab) to manage merge requests, issues, pipelines, and repositories from the command line. | Any project hosted on GitLab (SaaS or self-hosted). |
 | [humanizer](./humanizer/SKILL.md) | Remove signs of AI-generated writing from text — inflated importance, promotional language, em dash overuse, rule of three, AI vocabulary, and filler phrases. | Editing or reviewing prose to make it sound more natural and human-written. |
 | [improve](./improve/SKILL.md) | Audit repositories as a read-only senior advisor and produce prioritized implementation plans for another agent. | Repository-wide audits, improvement roadmaps, and implementation handoffs. |

package/framework/skills/grilling/SKILL.md

@@ -0,0 +1,34 @@
+---
+name: grilling
+description: Grill the user relentlessly about a plan, decision, or idea. Use when the user wants to stress-test their thinking, or uses any 'grill' trigger phrases.
+---
+
+# grilling
+
+Interview the user relentlessly until you reach a shared understanding. Map this as a **design tree**: every decision branches into the decisions that hang off it.
+
+Work the tree in **rounds**. The **frontier** is every decision whose prerequisites are already settled: the questions you can ask _now_ without guessing at answers you haven't heard yet. Ask the whole frontier in one round: number each question and give your recommended answer. Then wait for the user's answers before the next round.
+
+Format a round like so:
+
+```
+❓ **Q1** - **<question title>**: <question body, might be multiple paragraphs, including multiple choices>
+
+➡️ <your recommended answer>
+
+---
+
+❓ **Q2** - **<question title>**: <question body, might be multiple paragraphs, including multiple choices>
+
+➡️ <your recommended answer>
+```
+
+Each round the user answers reshapes the tree: settled decisions push the frontier outward and unblock questions that depended on them. Recompute the frontier and ask the next round. A question whose answer depends on another question still open in this round belongs to a _later_ round, not this one.
+
+Finding _facts_ is your job, never the user's. When a frontier question needs a fact from the environment (filesystem, tools, etc.), dispatch a sub-agent to find it; don't ask the user for anything you could look up yourself. Don't block on it: a running exploration is an unsettled prerequisite, so only the questions downstream of it wait for the sub-agent to report; ask the rest of the frontier now. The _decisions_ are the user's: put each to them and wait.
+
+The session is done when the frontier is empty: every branch of the design tree visited, nothing left silently assumed. Do not act on it until the user confirms you have reached a shared understanding.
+
+## Source
+
+Adapted from [skills](https://github.com/mattpocock/skills/blob/main/skills/productivity/grilling/SKILL.md) by Matt Pocock, MIT License.

package/framework/skills/grilling/examples.md

@@ -0,0 +1,47 @@
+# Grilling Skill — Example Outputs
+
+Realistic examples of how the `grilling` skill stress-tests thinking through design-tree rounds.
+
+## Example 1: New feature plan (frontier round, recommendations, wait)
+
+**User:** "Grill me on my plan to add Redis caching to the API."
+
+**What the agent does:**
+
+Maps the design tree (invalidation strategy branches off what is cached; TTL branches off invalidation; cache key shape branches off endpoints covered), computes the frontier, and asks round 1:
+
+```
+❓ **Q1** - **What gets cached**: Which endpoints or queries go through Redis — everything, read-heavy endpoints only, or specific hot queries?
+
+➡️ Read-heavy endpoints only. Caching everything multiplies invalidation bugs for little gain.
+
+---
+
+❓ **Q2** - **Where Redis lives**: Managed service (Upstash/ElastiCache), self-hosted container, or reuse existing infrastructure?
+
+➡️ Managed service. One less stateful thing to operate for a first caching pass.
+```
+
+Then waits. Q3 (TTL values) stays out of this round — it depends on Q1's answer.
+
+**Result:** Whole frontier asked at once, each with a recommendation, no guessing at unsettled answers.
+
+## Example 2: Facts via sub-agent, decisions via user (don't block)
+
+**User:** Answers Q1 with "specific hot queries" and Q2 with "self-hosted container."
+
+**What the agent does:**
+
+Settled decisions push the frontier outward. Q3 (TTL per query) is now askable. But "which queries are actually hot" is a fact, not a decision — dispatches a sub-agent to check access logs and slow-query stats instead of asking the user. Asks the rest of the frontier now (eviction policy, invalidation trigger); only the TTL question waits for the sub-agent's report.
+
+**Result:** Facts looked up, decisions put to the user, no blocking on exploration.
+
+## Example 3: Session close (frontier empty, confirm before acting)
+
+**User:** Answers the final round on invalidation triggers.
+
+**What the agent does:**
+
+Frontier is empty — every branch visited (scope, hosting, TTLs, eviction, invalidation). States the shared understanding back in one summary and asks for confirmation. Does not write any code or config until the user confirms.
+
+**Result:** Nothing silently assumed, no action before confirmed understanding.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mohammadhprp/system-prompt",
-  "version": "0.13.0",
+  "version": "0.13.2",
   "description": "AI Coding Agent Framework — interactive bootstrap CLI",
   "keywords": [
     "ai",

package/src/catalog.js

@@ -3,6 +3,7 @@ export const categories = {
     title: 'Skills',
     description: 'Task-specific procedures for AI coding agents',
     sourceDir: 'framework/skills',
+    itemLayout: 'directory',
     items: [
       { id: 'adhd', name: 'ADHD', description: 'Shape output for ADHD readers: action first, numbered steps, restated state, no tangents' },
       { id: 'agent-browser', name: 'Agent Browser', description: 'Automate browser and Electron workflows for navigation, testing, screenshots, and data extraction' },
@@ -17,6 +18,7 @@ export const categories = {
       { id: 'effective-html', name: 'Effective HTML', description: 'Create self-contained HTML artifacts with routed guidance for design, wireframes, prototypes, plans, and diagrams' },
       { id: 'find-skills', name: 'Find Skills', description: 'Discover, evaluate, and install agent skills for specialized tasks' },
       { id: 'frontend-design', name: 'Frontend Design', description: 'Distinctive, intentional visual design for new UI or reshaping existing UI' },
+      { id: 'grilling', name: 'Grilling', description: 'Grill plans and decisions relentlessly through design-tree rounds until shared understanding is reached' },
       { id: 'gh', name: 'GitHub CLI', description: 'Work with GitHub via the gh CLI for repositories, issues, pull requests, Actions, releases, and APIs' },
       { id: 'glab', name: 'Glab', description: 'Work with GitLab via the glab CLI for MRs, issues, and pipelines' },
       { id: 'humanizer', name: 'Humanizer', description: 'Remove signs of AI-generated writing to make text sound more natural and human' },
@@ -46,6 +48,7 @@ export const categories = {
     title: 'Subagents',
     description: 'Specialized subagents for security, architecture, review, and research',
     sourceDir: 'framework/agents',
+    itemLayout: 'file',
     items: [
       { id: 'researcher', name: 'Researcher', description: 'Fetch and analyze web content from URLs' },
       { id: 'reviewer', name: 'Reviewer', description: 'Review code for correctness and best practices' },
@@ -57,6 +60,7 @@ export const categories = {
     title: 'Slash Commands',
     description: 'Slash command workflows for repeatable tasks',
     sourceDir: 'framework/commands',
+    itemLayout: 'file',
     items: [
       { id: 'audit-your-codebase', name: 'Audit Your Codebase', description: 'Audit for materially useful simplifications in structure, state, algorithms, and ownership' },
       { id: 'explain-codebase', name: 'Explain Codebase', description: 'Map a codebase and teach it interactively, from overview to focused deep-dives' },
@@ -69,6 +73,8 @@ export const categories = {
     title: 'MCPs',
     description: 'Model Context Protocol servers for AI coding agents',
     sourceDir: 'framework/mcps',
+    itemLayout: 'directory',
+    copyItems: false,
     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' },
@@ -82,6 +88,8 @@ export const categories = {
     title: 'Plugins',
     description: 'OpenCode plugins that extend the core agent',
     sourceDir: 'framework/plugins',
+    itemLayout: 'directory',
+    copyItems: false,
     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' },
@@ -92,6 +100,7 @@ export const categories = {
     title: 'Styles',
     description: 'Design system references from Refero Styles',
     sourceDir: 'framework/styles',
+    itemLayout: 'directory',
     items: [
       { id: 'factory', name: 'Factory', description: 'Terminal war room design system' },
       { id: 'huly', name: 'Huly', description: 'Midnight observatory design system' },
@@ -105,6 +114,7 @@ export const categories = {
     title: 'Modes',
     description: 'Behavior, tool, and prompt presets for different use cases',
     sourceDir: 'framework/modes',
+    itemLayout: 'file',
     items: [
       { id: 'audit', name: 'Audit', description: 'Read-only high-scrutiny review mode for evaluating artifacts' },
     ],
@@ -114,6 +124,7 @@ export const categories = {
     title: 'Memory',
     description: 'Persistent agent memory files for cross-session context',
     sourceDir: 'framework/memory',
+    itemLayout: 'file',
     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' },
@@ -124,6 +135,7 @@ export const categories = {
     title: 'Standards',
     description: 'Canonical engineering standards',
     sourceDir: 'framework/references/standards',
+    itemLayout: 'file',
     items: [
       { id: 'api', name: 'API Design', description: 'REST API design standards' },
       { id: 'architecture', name: 'Architecture', description: 'System architecture standards' },
@@ -144,6 +156,7 @@ export const categories = {
     title: 'Templates',
     description: 'Fillable workflow documents',
     sourceDir: 'framework/references/templates',
+    itemLayout: 'file',
     items: [
       { id: 'adr', name: 'ADR', description: 'Architecture Decision Record' },
       { id: 'api-spec', name: 'API Spec', description: 'API specification document' },

package/src/cli/args.js

@@ -0,0 +1,51 @@
+import { categories } from '../catalog.js';
+
+const CATEGORY_FLAGS = new Set(Object.keys(categories));
+
+export function parseArgs(argv) {
+  const options = {
+    targetDir: '.opencode',
+    selections: {},
+    all: false,
+    dryRun: false,
+    force: false,
+    doctor: false,
+    includeAgentsMd: true,
+  };
+  for (let index = 0; index < argv.length; index += 1) {
+    const arg = argv[index];
+    if (arg === '--all') options.all = true;
+    else if (arg === '--dry-run') options.dryRun = true;
+    else if (arg === '--force') options.force = true;
+    else if (arg === '--doctor') options.doctor = true;
+    else if (arg === '--no-agents-md') options.includeAgentsMd = false;
+    else if (arg === '--target') {
+      const value = argv[++index];
+      if (!value || value.startsWith('--')) throw new Error('Missing value for --target');
+      options.targetDir = value;
+    }
+    else if (arg.startsWith('--target=')) {
+      const value = arg.slice('--target='.length);
+      if (!value) throw new Error('Missing value for --target');
+      options.targetDir = value;
+    }
+    else if (arg.startsWith('--')) {
+      const [flag, inlineValue] = arg.slice(2).split('=', 2);
+      if (!CATEGORY_FLAGS.has(flag)) throw new Error(`Unknown option: ${arg}`);
+      const value = inlineValue ?? argv[++index];
+      if (!value) throw new Error(`Missing value for --${flag}`);
+      options.selections[flag] = value.split(',').filter(Boolean);
+    } else {
+      throw new Error(`Unknown argument: ${arg}`);
+    }
+  }
+  options.nonInteractive = options.all || Object.keys(options.selections).length > 0;
+  return options;
+}
+
+export function allSelections() {
+  return Object.fromEntries(Object.entries(categories).map(([category, config]) => [
+    category,
+    config.items.filter(item => !item.removed).map(item => item.id),
+  ]));
+}

package/src/cli/clack-ui.js

@@ -0,0 +1,13 @@
+import { confirm, intro, isCancel, multiselect, note, outro, select, spinner } from '@clack/prompts';
+
+export const defaultUi = {
+  intro,
+  outro,
+  confirm,
+  multiselect,
+  spinner,
+  select,
+  note,
+  isCancel,
+  log: (...args) => console.log(...args),
+};

package/src/cli/index.js

@@ -0,0 +1,47 @@
+import { resolve } from 'node:path';
+
+import { doctor } from '../doctor.js';
+import { install } from '../install/index.js';
+import { loadLockFile, lockToSelections } from '../install/lock.js';
+import { getPackageVersion } from '../paths.js';
+import { status } from '../ui.js';
+import { allSelections, parseArgs } from './args.js';
+import { defaultUi } from './clack-ui.js';
+import { runInteractive } from './interactive.js';
+
+export async function runNonInteractive({ targetDir, selections, all, includeAgentsMd, force = false, dryRun = false, agentType = 'opencode', ui = defaultUi }) {
+  const resolvedSelections = all ? allSelections() : selections;
+  const absTarget = resolve(process.cwd(), targetDir);
+  const oldLock = await loadLockFile(absTarget);
+  if (!dryRun) ui.log(status('info', `Installing selected components into ${absTarget}`));
+  await install({
+    targetDir,
+    agentType,
+    selections: resolvedSelections,
+    includeAgentsMd,
+    oldSelections: oldLock ? lockToSelections(oldLock) : undefined,
+    oldLock,
+    force,
+    dryRun,
+  });
+  ui.log(status(dryRun ? 'info' : 'success', dryRun ? 'Dry run complete.' : 'Installation complete.'));
+}
+
+export async function main(argv = process.argv.slice(2)) {
+  const args = parseArgs(argv);
+  if (args.doctor) {
+    const healthy = await doctor(args.targetDir);
+    if (!healthy) process.exitCode = 1;
+    return healthy;
+  }
+
+  const version = await getPackageVersion();
+  defaultUi.intro(`System prompt  ·  v${version}`);
+
+  const agentType = 'opencode';
+
+  if (args.nonInteractive) {
+    return runNonInteractive({ ...args, agentType });
+  }
+  return runInteractive({ ...args, agentType });
+}

package/src/cli/interactive.js

@@ -0,0 +1,213 @@
+import { resolve } from 'node:path';
+
+import { categories } from '../catalog.js';
+import { install } from '../install/index.js';
+import { loadLockFile, lockToSelections } from '../install/lock.js';
+import { defaultUi } from './clack-ui.js';
+import {
+  buildSummary,
+  computeDiff,
+  fileList,
+  formatDiff,
+  generatedFiles,
+  initialItemValues,
+  shouldPreselectAll,
+} from './plan.js';
+import { collectTuiPreferences, readTuiPreferences } from './tui-preferences.js';
+
+function cancelled(ui) {
+  ui.outro('Cancelled.');
+  return { status: 'cancelled' };
+}
+
+function reportPlan({ ui, oldLock, selections, includeAgentsMd }) {
+  if (oldLock) {
+    const diffText = formatDiff(computeDiff(oldLock, selections));
+    ui.note(diffText || 'No changes — same selections as before.', 'Changes from previous installation');
+  } else {
+    ui.note(buildSummary(selections), 'What will be installed');
+  }
+  ui.note(fileList(generatedFiles(selections, includeAgentsMd)), 'Generated files');
+}
+
+async function collectSelections({ ui, selectedCategories, existingSelections }) {
+  const selections = {};
+  for (const cat of selectedCategories) {
+    const catConfig = categories[cat];
+    const visibleItems = catConfig.items.filter(item => !item.removed);
+    const existingIds = initialItemValues(visibleItems, existingSelections[cat] || []);
+
+    const all = await ui.confirm({
+      message: `Install all ${catConfig.title.toLowerCase()}?`,
+      initialValue: shouldPreselectAll(visibleItems, existingIds),
+    });
+    if (ui.isCancel(all)) return null;
+
+    if (all) {
+      selections[cat] = visibleItems.map(item => item.id);
+      continue;
+    }
+
+    const picked = await ui.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,
+      })),
+      initialValues: existingIds,
+      required: true,
+    });
+    if (ui.isCancel(picked)) return null;
+    selections[cat] = picked;
+  }
+  return selections;
+}
+
+async function installGeneratedFiles({ ui, targetDir, agentType, force, dryRun, oldLock, existingSelections, existingTuiPreferences }) {
+  const includeAgentsMd = await ui.confirm({
+    message: 'Generate AGENTS.md?',
+    initialValue: oldLock ? oldLock.includeAgentsMd : true,
+  });
+  if (ui.isCancel(includeAgentsMd)) return cancelled(ui);
+
+  const hasExisting = Object.keys(existingSelections).length > 0;
+  let keepExisting = false;
+  if (hasExisting) {
+    const removeAll = await ui.confirm({
+      message: 'Remove all previously installed components?',
+      initialValue: false,
+    });
+    if (ui.isCancel(removeAll)) return cancelled(ui);
+    keepExisting = !removeAll;
+  }
+
+  const progress = ui.spinner();
+  progress.start('Writing files...');
+  await install({
+    targetDir,
+    agentType,
+    selections: keepExisting ? existingSelections : {},
+    includeAgentsMd,
+    oldSelections: hasExisting ? existingSelections : undefined,
+    oldLock,
+    tuiPreferences: existingTuiPreferences,
+    force,
+    dryRun,
+  });
+  progress.stop('Done.');
+
+  ui.outro(includeAgentsMd ? 'AGENTS.md and configuration written.' : 'Configuration written.');
+  return { status: 'installed' };
+}
+
+async function installSelectedItems({ ui, targetDir, agentType, force, dryRun, oldLock, existingSelections, existingTuiPreferences }, selectedCategories) {
+  const includeAgentsMd = await ui.confirm({
+    message: 'Generate AGENTS.md?',
+    initialValue: oldLock ? oldLock.includeAgentsMd : true,
+  });
+  if (ui.isCancel(includeAgentsMd)) return cancelled(ui);
+
+  const selections = await collectSelections({ ui, selectedCategories, existingSelections });
+  if (!selections) return cancelled(ui);
+
+  let tuiPreferences = existingTuiPreferences;
+  const customizeTui = await ui.confirm({
+    message: 'Customize OpenCode TUI settings?',
+    initialValue: false,
+  });
+  if (ui.isCancel(customizeTui)) return cancelled(ui);
+  if (customizeTui) {
+    const custom = await collectTuiPreferences(existingTuiPreferences, ui);
+    if (!custom) return cancelled(ui);
+    tuiPreferences = custom;
+  }
+
+  if (oldLock) {
+    const initialDiff = computeDiff(oldLock, selections);
+    if (Object.keys(initialDiff.removed).length) {
+      const removeDeselected = await ui.confirm({
+        message: 'Remove deselected items from the previous installation?',
+        initialValue: false,
+      });
+      if (ui.isCancel(removeDeselected)) return cancelled(ui);
+      if (!removeDeselected) {
+        for (const [cat, data] of Object.entries(initialDiff.removed)) {
+          selections[cat] = [...new Set([...(selections[cat] || []), ...data.ids])];
+        }
+      }
+    }
+  }
+
+  reportPlan({ ui, oldLock, selections, includeAgentsMd });
+
+  const confirmed = await ui.confirm({
+    message: 'Proceed with installation?',
+    initialValue: true,
+  });
+  if (ui.isCancel(confirmed) || !confirmed) {
+    ui.outro('Installation cancelled.');
+    return { status: 'cancelled' };
+  }
+
+  const progress = ui.spinner();
+  progress.start(oldLock ? 'Updating files...' : 'Installing files...');
+
+  const finalTarget = await install({
+    targetDir,
+    agentType,
+    selections,
+    includeAgentsMd,
+    oldSelections: oldLock ? existingSelections : undefined,
+    oldLock,
+    tuiPreferences,
+    force,
+    dryRun,
+  });
+
+  progress.stop('Installation complete!');
+
+  const fileCount = Object.values(selections).reduce((sum, ids) => sum + (ids?.length || 0), 0);
+  const verb = oldLock ? 'Updated' : 'Installed';
+  ui.note(
+    [
+      agentType === 'opencode'
+        ? 'Open your project in OpenCode — it reads 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.',
+    ].join('\n'),
+    'Next steps',
+  );
+  ui.outro(`${verb} ${fileCount} components to ${finalTarget}`);
+  return { status: 'installed', target: finalTarget };
+}
+
+export async function runInteractive({ targetDir, force = false, dryRun = false, agentType = 'opencode', ui = defaultUi }) {
+  const absTarget = resolve(process.cwd(), targetDir);
+  const oldLock = await loadLockFile(absTarget);
+  const existingSelections = lockToSelections(oldLock);
+  const existingTuiPreferences = await readTuiPreferences(absTarget);
+  const context = { ui, targetDir, agentType, force, dryRun, oldLock, existingSelections, existingTuiPreferences };
+
+  const selectedCategories = await ui.multiselect({
+    message: 'What would you like to install?',
+    options: buildCategoryOptions(),
+    initialValues: Object.keys(existingSelections),
+    required: false,
+  });
+  if (ui.isCancel(selectedCategories)) return cancelled(ui);
+
+  if (!selectedCategories?.length) return installGeneratedFiles(context);
+  return installSelectedItems(context, selectedCategories);
+}
+
+function buildCategoryOptions() {
+  return Object.entries(categories).map(([key, cat]) => {
+    const visible = cat.items.filter(item => !item.removed);
+    return {
+      value: key,
+      label: cat.title,
+      hint: `${visible.length} ${key === 'mcps' ? 'MCPs' : cat.title.toLowerCase()}`,
+    };
+  });
+}

package/src/cli/plan.js

@@ -0,0 +1,85 @@
+import { categories } from '../catalog.js';
+import { lockToSelections } from '../install/lock.js';
+
+export function computeDiff(oldLock, selections) {
+  const oldSels = lockToSelections(oldLock);
+  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 };
+}
+
+export function formatDiff(diff) {
+  const sections = [
+    ['+ Added', diff.added],
+    ['- Removed', diff.removed],
+    ['~ Unchanged', diff.kept],
+  ];
+  const lines = [];
+
+  for (const [label, group] of sections) {
+    const entries = Object.entries(group);
+    if (!entries.length) continue;
+    if (lines.length) lines.push('');
+    lines.push(`  ${label}:`);
+    for (const [cat, data] of entries) {
+      lines.push(`    ${data.config?.title || cat}: ${itemNames(data.config, data.ids).join(', ')}`);
+    }
+  }
+
+  return lines.join('\n');
+}
+
+export function initialItemValues(visibleItems, existingIds = []) {
+  const visible = new Set(visibleItems.map(item => item.id));
+  return existingIds.filter(id => visible.has(id));
+}
+
+export function shouldPreselectAll(visibleItems, existingIds = []) {
+  if (existingIds.length) return existingIds.length === visibleItems.length;
+  return visibleItems.length <= 12;
+}
+
+export function buildSummary(selections) {
+  const lines = [];
+  for (const [cat, ids] of Object.entries(selections)) {
+    if (!ids?.length) continue;
+    const catConfig = categories[cat];
+    lines.push(`• ${catConfig?.title || cat}: ${itemNames(catConfig, ids).join(', ')}`);
+  }
+  return lines.join('\n');
+}
+
+export function generatedFiles(selections, includeAgentsMd) {
+  const files = [];
+  if (includeAgentsMd) files.push('AGENTS.md');
+  files.push('opencode.json', 'tui.json', '.gitignore');
+  if (selections.mcps?.length) files.push('.env');
+  if (selections.memory?.length) files.push('memory/');
+  return files;
+}
+
+export function fileList(files) {
+  return files.map(file => `• ${file}`).join('\n');
+}
+
+function itemNames(config, ids) {
+  return ids.map(id => config?.items?.find(item => item.id === id)?.name || id);
+}