@mohammadhprp/system-prompt 0.13.1 → 0.13.2

package/src/install/merge.js

@@ -0,0 +1,62 @@
+import { readFile } from 'node:fs/promises';
+
+import { isMissing } from '../paths.js';
+import { writeManagedFile } from './files.js';
+import { OPENCODE_GITIGNORE } from './templates.js';
+
+export async function mergeJsonFile(destFile, generated, relativePath, options, previousGenerated = generated) {
+  let existing = {};
+  try {
+    existing = JSON.parse(await readFile(destFile, 'utf-8'));
+  } catch (error) {
+    if (!isMissing(error)) {
+      if (error instanceof SyntaxError) throw new Error(`Cannot merge invalid JSON file: ${relativePath}`);
+      throw error;
+    }
+  }
+  const merged = { ...existing, ...generated };
+  if (Array.isArray(existing.instructions) && Array.isArray(generated.instructions)) {
+    const previous = new Set(previousGenerated.instructions || []);
+    merged.instructions = [...new Set([
+      ...existing.instructions.filter(item => !previous.has(item)),
+      ...generated.instructions,
+    ])];
+  }
+  if (Array.isArray(existing.plugin)) {
+    const previous = new Set(previousGenerated.plugin || []);
+    const plugins = [...new Set([
+      ...existing.plugin.filter(item => !previous.has(item)),
+      ...(generated.plugin || []),
+    ])];
+    if (plugins.length) merged.plugin = plugins;
+    else delete merged.plugin;
+  }
+  for (const key of ['mcp', 'references']) {
+    if (existing[key] && typeof existing[key] === 'object') {
+      const previous = previousGenerated[key] || {};
+      const preserved = Object.fromEntries(Object.entries(existing[key]).filter(([name]) => !(name in previous)));
+      const values = { ...preserved, ...(generated[key] || {}) };
+      if (Object.keys(values).length) merged[key] = values;
+      else delete merged[key];
+    }
+  }
+  return writeManagedFile(destFile, Buffer.from(JSON.stringify(merged, null, 4)), relativePath, {
+    ...options,
+    allowExistingMerge: !options.oldLock,
+  }, { generated: true });
+}
+
+export async function mergeGitignore(destFile, options) {
+  let existing = '';
+  try {
+    existing = await readFile(destFile, 'utf-8');
+  } catch (error) {
+    if (!isMissing(error)) throw error;
+  }
+  const lines = new Set(existing.split('\n').filter(Boolean));
+  for (const line of OPENCODE_GITIGNORE.split('\n').filter(Boolean)) lines.add(line);
+  return writeManagedFile(destFile, Buffer.from(`${[...lines].join('\n')}\n`), '.gitignore', {
+    ...options,
+    allowExistingMerge: !options.oldLock,
+  }, { generated: true });
+}

package/src/install/templates.js

@@ -0,0 +1,76 @@
+export const AGENTS_MD = `# AGENTS.md
+
+Behavioral guidelines to reduce common LLM coding mistakes. Merge with project-specific instructions as needed.
+
+Read CONTEXT.md for repository-specific setup, commands, architecture, tests, and workflow guidance.
+
+**Tradeoff:** These guidelines bias toward caution over speed. For trivial tasks, use judgment.
+
+## 1. Think Before Coding
+
+**Don't assume. Don't hide confusion. Surface tradeoffs.**
+
+Before implementing:
+- State your assumptions explicitly. If uncertain, ask.
+- If multiple interpretations exist, present them - don't pick silently.
+- If a simpler approach exists, say so. Push back when warranted.
+- If something is unclear, stop. Name what's confusing. Ask.
+
+## 2. Simplicity First
+
+**Minimum code that solves the problem. Nothing speculative.**
+
+- No features beyond what was asked.
+- No abstractions for single-use code.
+- No "flexibility" or "configurability" that wasn't requested.
+- No error handling for impossible scenarios.
+- If you write 200 lines, and it could be 50, rewrite it.
+
+Ask yourself: "Would a senior engineer say this is overcomplicated?" If yes, simplify.
+
+## 3. Surgical Changes
+
+**Touch only what you must. Clean up only your own mess.**
+
+When editing existing code:
+- Don't "improve" adjacent code, comments, or formatting.
+- Don't refactor things that aren't broken.
+- Match existing style, even if you'd do it differently.
+- If you notice unrelated dead code, mention it - don't delete it.
+
+When your changes create orphans:
+- Remove imports/variables/functions that YOUR changes made unused.
+- Don't remove pre-existing dead code unless asked.
+
+The test: Every changed line should trace directly to the user's request.
+
+## 4. Goal-Driven Execution
+
+**Define success criteria. Loop until verified.**
+
+Transform tasks into verifiable goals:
+- "Add validation" → "Write tests for invalid inputs, then make them pass"
+- "Fix the bug" → "Write a test that reproduces it, then make it pass"
+- "Refactor X" → "Ensure tests pass before and after"
+
+For multistep tasks, state a brief plan:
+
+1. [Step] → verify: [check]
+2. [Step] → verify: [check]
+3. [Step] → verify: [check]
+
+
+Strong success criteria let you loop independently. Weak criteria ("make it work") require constant clarification.
+
+---
+
+**These guidelines are working if:** fewer unnecessary changes in diffs, fewer rewrites due to overcomplication, and clarifying questions come before implementation rather than after mistakes.
+
+`;
+
+export const OPENCODE_GITIGNORE = `.env*
+node_modules
+package.json
+package-lock.json
+bun.lock
+`;

package/src/item-layout.js

@@ -24,3 +24,8 @@ export function itemRelativePath(category, id) {
   const dir = targetSubdir(categories[category].sourceDir);
   return isFileBased(category) ? `${dir}/${id}.md` : `${dir}/${id}`;
 }
+
+export function isRemoved(category, id) {
+  const item = categories[category]?.items.find(entry => entry.id === id);
+  return item?.removed === true;
+}

package/src/paths.js

@@ -0,0 +1,59 @@
+import { fileURLToPath } from 'node:url';
+import { dirname, isAbsolute, relative, resolve } from 'node:path';
+import { lstat, readFile } from 'node:fs/promises';
+
+const moduleDir = dirname(fileURLToPath(import.meta.url));
+
+export const packageRoot = resolve(moduleDir, '..');
+
+export function resolveSource(subpath) {
+  return resolve(packageRoot, subpath);
+}
+
+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 function isMissing(error) {
+  return error?.code === 'ENOENT';
+}
+
+function isInside(parent, child) {
+  const relativePath = relative(parent, child);
+  return relativePath === '' || (!relativePath.startsWith('../') && relativePath !== '..' && !isAbsolute(relativePath));
+}
+
+export function assertSafePath(targetDir, path) {
+  if (!isInside(targetDir, path)) {
+    throw new Error(`Refusing to access path outside installation directory: ${path}`);
+  }
+}
+
+export async function assertSafeDestination(targetDir, path) {
+  assertSafePath(targetDir, path);
+  try {
+    if ((await lstat(targetDir)).isSymbolicLink()) {
+      throw new Error(`Refusing to install through symlink target: ${targetDir}`);
+    }
+  } catch (error) {
+    if (!isMissing(error)) throw error;
+  }
+  const relativePath = relative(targetDir, path);
+  let current = targetDir;
+  for (const part of relativePath.split('/').filter(Boolean)) {
+    current = resolve(current, part);
+    try {
+      if ((await lstat(current)).isSymbolicLink()) {
+        throw new Error(`Refusing to access symlink inside installation directory: ${current}`);
+      }
+    } catch (error) {
+      if (isMissing(error)) break;
+      throw error;
+    }
+  }
+}

package/src/ui.js

@@ -0,0 +1,32 @@
+const RESET = '\u001b[0m';
+
+const COLORS = {
+  red: '\u001b[31m',
+  green: '\u001b[32m',
+  yellow: '\u001b[33m',
+  cyan: '\u001b[36m',
+};
+
+const STATUS = {
+  success: { symbol: '✓', color: 'green' },
+  info: { symbol: '›', color: 'cyan' },
+  warn: { symbol: '!', color: 'yellow' },
+  error: { symbol: '✗', color: 'red' },
+};
+
+export function colorEnabled(stream = process.stdout) {
+  if ('NO_COLOR' in process.env) return false;
+  if (process.env.FORCE_COLOR && process.env.FORCE_COLOR !== '0') return true;
+  return Boolean(stream?.isTTY);
+}
+
+function style(text, color, { enabled = colorEnabled() } = {}) {
+  const code = COLORS[color];
+  if (!enabled || !code) return text;
+  return `${code}${text}${RESET}`;
+}
+
+export function status(kind, message, options = {}) {
+  const config = STATUS[kind] || STATUS.info;
+  return `${style(config.symbol, config.color, options)} ${message}`;
+}