@mohammadhprp/system-prompt 0.11.1 → 0.12.0

package/package.json

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

package/src/agent-configs.js

@@ -15,8 +15,12 @@ export async function loadMcpConfigs(selectedIds) {
       if (parsed.mcp) {
         Object.assign(entries, parsed.mcp);
       }
-    } catch {
-      console.warn(`  ⚠  No opencode.json config found for MCP: ${id}`);
+    } catch (error) {
+      if (error.code === 'ENOENT') {
+        console.warn(`  ⚠  No opencode.json config found for MCP: ${id}`);
+        continue;
+      }
+      throw error;
     }
   }
   return entries;

package/src/catalog.js

@@ -6,20 +6,33 @@ export const categories = {
     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: 'codenavi', name: 'CodeNavi', description: 'Navigate unknown codebases with precision, a persistent .notebook knowledge base, and surgical implementation' },
+      { id: 'create-adr', name: 'Create ADR', description: 'Create Architecture Decision Records documenting significant architectural choices and rationale' },
       { 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: 'docs-writer', name: 'Docs Writer', description: 'Write, review, and edit documentation files with consistent structure, tone, and technical accuracy' },
       { 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: 'gitlab-mcp', name: 'GitLab MCP', description: 'Work with GitLab via MCP for MRs, issues, pipelines' },
+      { id: 'humanizer', name: 'Humanizer', description: 'Remove signs of AI-generated writing to make text sound more natural and human' },
       { 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: 'learning-opportunities', name: 'Learning Opportunities', description: 'Facilitate deliberate skill development during AI-assisted coding with short, interactive exercises' },
       { 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' }
+      { id: 'perf-web-optimization', name: 'Web Performance Optimization', description: 'Optimize web performance: bundle size, images, caching, lazy loading, and overall page speed' },
+      { id: 'security-best-practices', name: 'Security Best Practices', description: 'Language and framework specific security best-practice reviews and secure-by-default coding help' },
+      { id: 'sentry', name: 'Sentry', description: 'Inspect Sentry issues, summarize production errors, and pull health data via the Sentry API' },
+      { id: 'show-me', name: 'Show Me', description: 'Explain the current topic visually with diagrams, code-shape sketches, and focused HTML artifacts' },
+      { id: 'skill-creator', name: 'Skill Creator', description: 'Create and evaluate new agent skills' },
+      { id: 'spec-driven-eval', name: 'Spec-Driven Eval', description: 'Score how completely an implementation fulfills a PRD/spec, case by case, into a single comparable grade' },
+      { id: 'technical-design-doc-creator', name: 'Technical Design Doc Creator', description: 'Create comprehensive Technical Design Documents with mandatory and optional sections through interactive discovery' },
+      { id: 'taste', name: 'Taste', description: 'Unified design-quality skill spanning anti-slop frontend, image generation and image-to-code, brand kits, minimalist and industrial UI, and Google Stitch design systems' },
+      { id: 'tlc-spec-driven', name: 'TLC Spec-Driven', description: 'Feature planning and implementation with adaptive phases, EARS testable requirements, atomic commits, and independent verification' },
+      { id: 'web-design-guidelines', name: 'Web Design Guidelines', description: 'Review UI code for Web Interface Guidelines compliance: accessibility, interaction patterns, and design best practices' }
     ],
   },
 

package/src/cli.js

@@ -3,6 +3,57 @@ import { resolve } from 'node:path';
 
 import { categories } from './catalog.js';
 import { getPackageVersion, install, loadLockFile } from './installer.js';
+import { doctor } from './doctor.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;
+}
+
+function allSelections() {
+  return Object.fromEntries(Object.entries(categories).map(([category, config]) => [
+    category,
+    config.items.filter(item => !item.removed).map(item => item.id),
+  ]));
+}
 
 function buildSummary(selections) {
   const lines = [];
@@ -86,12 +137,38 @@ function formatDiff(diff) {
   return lines.join('\n');
 }
 
-export async function main() {
+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();
   intro(`System prompt (v${version})`);
 
   const agentType = 'opencode';
-  const targetDir = '.opencode';
+  const targetDir = args.targetDir;
+
+  if (args.nonInteractive) {
+    const selections = args.all ? allSelections() : args.selections;
+    const absTarget = resolve(process.cwd(), targetDir);
+    const oldLock = await loadLockFile(absTarget);
+    if (!args.dryRun) console.log(`Installing selected components into ${absTarget}`);
+    await install({
+      targetDir,
+      agentType,
+      selections,
+      includeAgentsMd: args.includeAgentsMd,
+      oldSelections: oldLock?.selections,
+      oldLock,
+      force: args.force,
+      dryRun: args.dryRun,
+    });
+    console.log(args.dryRun ? 'Dry run complete.' : 'Installation complete.');
+    return;
+  }
 
   const categoryOptions = Object.entries(categories).map(([key, cat]) => {
     const visible = cat.items.filter(i => !i.removed);
@@ -239,6 +316,9 @@ export async function main() {
     selections,
     includeAgentsMd,
     oldSelections: oldLock?.selections,
+    oldLock,
+    force: args.force,
+    dryRun: args.dryRun,
   });
 
   s.stop('Installation complete!');

package/src/doctor.js

@@ -0,0 +1,84 @@
+import { resolve } from 'node:path';
+import { access, readFile } from 'node:fs/promises';
+import { createHash } from 'node:crypto';
+
+import { categories } from './catalog.js';
+import { loadLockFile } from './installer.js';
+
+async function exists(path) {
+  try {
+    await access(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+export async function inspectInstallation(targetDir) {
+  const absTarget = resolve(process.cwd(), targetDir);
+  const issues = [];
+  let lock;
+
+  try {
+    lock = await loadLockFile(absTarget);
+  } catch (error) {
+    issues.push(error.message);
+    return { targetDir: absTarget, issues };
+  }
+
+  if (!lock) {
+    issues.push('No system-prompt-lock.json found.');
+    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 [category, ids] of Object.entries(lock.selections)) {
+    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)))) {
+        issues.push(`Missing installed ${category} item: ${id}`);
+      }
+    }
+  }
+
+  if (lock.agentType === 'opencode') {
+    for (const file of ['opencode.json', 'tui.json']) {
+      const path = resolve(absTarget, file);
+      if (!(await exists(path))) {
+        issues.push(`Missing generated file: ${file}`);
+        continue;
+      }
+      try {
+        JSON.parse(await readFile(path, 'utf-8'));
+      } catch {
+        issues.push(`Invalid JSON: ${file}`);
+      }
+    }
+  }
+
+  return { targetDir: absTarget, issues };
+}
+
+export async function doctor(targetDir = '.opencode', output = console.log) {
+  const result = await inspectInstallation(targetDir);
+  output(`Checking ${result.targetDir}`);
+  if (result.issues.length === 0) {
+    output('No issues found.');
+    return true;
+  }
+  for (const issue of result.issues) output(`  ⚠  ${issue}`);
+  return false;
+}