@mohammadhprp/system-prompt 0.13.0 → 0.13.2

package/src/install/index.js

@@ -0,0 +1,124 @@
+import { mkdir } from 'node:fs/promises';
+import { resolve } from 'node:path';
+
+import { categories } from '../catalog.js';
+import { loadMcpConfigs } from '../config/mcp.js';
+import { generateOpenCodeConfig } from '../config/opencode.js';
+import { generateTuiConfig } from '../config/tui.js';
+import { LOCK_CATEGORIES, isCopyable, isFileBased } from '../item-layout.js';
+import { getPackageVersion } from '../paths.js';
+import { collectMcpEnvExamples, writeMergedEnv } from './env.js';
+import { copySelectedDirs, copySelectedFiles, deleteSelectedItems, writeManagedFile } from './files.js';
+import { createLockData, lockToSelections, validateLock, writeLockFile } from './lock.js';
+import { mergeGitignore, mergeJsonFile } from './merge.js';
+import { AGENTS_MD } from './templates.js';
+
+export function validateSelections(selections) {
+  if (!selections || typeof selections !== 'object' || Array.isArray(selections)) {
+    throw new Error('Selections must be an object');
+  }
+  for (const [category, ids] of Object.entries(selections)) {
+    const config = categories[category];
+    if (!config || !Array.isArray(ids)) throw new Error(`Unknown or invalid category: ${category}`);
+    const knownIds = new Set(config.items.map(item => item.id));
+    if (ids.some(id => !knownIds.has(id))) throw new Error(`Unknown ${category} item selected`);
+  }
+  return selections;
+}
+
+export async function install({ targetDir, agentType, selections, includeAgentsMd = true, writeAgentsMd, oldSelections, oldLock, force = false, dryRun = false, tuiPreferences }) {
+  validateSelections(selections);
+  if (oldLock) validateLock(oldLock);
+  writeAgentsMd = writeAgentsMd ?? includeAgentsMd;
+  const absTarget = resolve(process.cwd(), targetDir);
+  if (!dryRun) await mkdir(absTarget, { recursive: true });
+  const options = {
+    targetDir: absTarget,
+    oldLock,
+    force,
+    dryRun,
+    managedFiles: {},
+    fileOwners: {},
+  };
+  if (oldLock) {
+    for (const category of LOCK_CATEGORIES) {
+      for (const [id, entry] of Object.entries(oldLock[category] || {})) {
+        for (const [path, checksum] of Object.entries(entry.files || {})) {
+          if (!(path in options.managedFiles)) {
+            options.managedFiles[path] = checksum;
+            options.fileOwners[path] = { category, id };
+          }
+        }
+      }
+    }
+    for (const [path, entry] of Object.entries(oldLock.generated || {})) {
+      if (!(path in options.managedFiles)) {
+        options.managedFiles[path] = entry.computedHash;
+        options.fileOwners[path] = { generated: 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));
+      await deleteSelectedItems(absTarget, cat, removedIds, oldLock, force, dryRun);
+    }
+  }
+
+  const tasks = [];
+  for (const category of LOCK_CATEGORIES) {
+    if (!isCopyable(category) || !selections[category]?.length) continue;
+    tasks.push(isFileBased(category)
+      ? copySelectedFiles(absTarget, category, selections[category], options)
+      : copySelectedDirs(absTarget, category, selections[category], options));
+  }
+  await Promise.all(tasks);
+
+  if (writeAgentsMd) {
+    await writeManagedFile(resolve(absTarget, 'AGENTS.md'), Buffer.from(AGENTS_MD), 'AGENTS.md', options, { generated: true });
+  }
+
+  if (agentType === 'opencode') {
+    let mcpEntries = {};
+    if (selections.mcps?.length) mcpEntries = await loadMcpConfigs(selections.mcps);
+    let previousOpenCodeConfig;
+    let previousTuiConfig;
+    if (oldLock) {
+      const previousSelections = lockToSelections(oldLock);
+      let previousMcpEntries = {};
+      if (previousSelections.mcps?.length) previousMcpEntries = await loadMcpConfigs(previousSelections.mcps);
+      previousOpenCodeConfig = JSON.parse(generateOpenCodeConfig({
+        selections: previousSelections,
+        mcpEntries: previousMcpEntries,
+        includeAgentsMd: oldLock.includeAgentsMd ?? true,
+      }));
+      previousTuiConfig = JSON.parse(generateTuiConfig({ selections: previousSelections, preferences: tuiPreferences }));
+    }
+    const configJson = generateOpenCodeConfig({ selections, mcpEntries, includeAgentsMd });
+    await mergeJsonFile(resolve(absTarget, 'opencode.json'), JSON.parse(configJson), 'opencode.json', options, previousOpenCodeConfig);
+    await mergeJsonFile(resolve(absTarget, 'tui.json'), JSON.parse(generateTuiConfig({ selections, preferences: tuiPreferences })), 'tui.json', options, previousTuiConfig);
+    await mergeGitignore(resolve(absTarget, '.gitignore'), options);
+  }
+
+  if (selections.mcps?.length) {
+    const envExamples = await collectMcpEnvExamples(selections.mcps);
+    await writeMergedEnv(absTarget, envExamples, options);
+  }
+
+  if (dryRun) return absTarget;
+  const pkgVersion = await getPackageVersion();
+  const lockData = createLockData({
+    agentType,
+    includeAgentsMd,
+    selections,
+    managedFiles: options.managedFiles,
+    fileOwners: options.fileOwners,
+    source: `system-prompt@${pkgVersion}`,
+  });
+  await writeLockFile(absTarget, lockData);
+  return absTarget;
+}

package/src/install/lock.js

@@ -0,0 +1,159 @@
+import { readFile, writeFile } from 'node:fs/promises';
+import { resolve } from 'node:path';
+
+import { categories } from '../catalog.js';
+import { hash } from '../hash.js';
+import { LOCK_CATEGORIES, isRemoved, itemSourcePath } from '../item-layout.js';
+import { isMissing } from '../paths.js';
+
+export const LOCK_VERSION = 1;
+
+export function lockToSelections(lock) {
+  const selections = {};
+  if (!lock) return selections;
+  for (const category of LOCK_CATEGORIES) {
+    const ids = Object.keys(lock[category] || {});
+    if (ids.length) selections[category] = ids;
+  }
+  return selections;
+}
+
+export function getExpectedHash(oldLock, relativePath) {
+  const generated = oldLock?.generated?.[relativePath]?.computedHash;
+  if (generated) return generated;
+  for (const category of LOCK_CATEGORIES) {
+    const entries = oldLock?.[category];
+    if (!entries) continue;
+    for (const entry of Object.values(entries)) {
+      const value = entry?.files?.[relativePath];
+      if (value) return value;
+    }
+  }
+  return undefined;
+}
+
+export async function loadLockFile(absTarget) {
+  try {
+    const content = await readFile(resolve(absTarget, 'system-prompt-lock.json'), 'utf-8');
+    const lock = JSON.parse(content);
+    validateLock(lock);
+    return lock;
+  } catch (error) {
+    if (isMissing(error)) return null;
+    if (error instanceof SyntaxError || error.message?.startsWith('Invalid system-prompt lock')) {
+      throw new Error(`${error.message}. Remove or repair system-prompt-lock.json before reinstalling.`);
+    }
+    throw error;
+  }
+}
+
+export function validateLock(lock) {
+  if (!lock || typeof lock !== 'object' || Array.isArray(lock)) {
+    throw new Error('Invalid system-prompt lock: expected an object');
+  }
+  if (lock.selections !== undefined || lock.managedFiles !== undefined) {
+    throw new Error('Invalid system-prompt lock: legacy lock format no longer supported');
+  }
+  if (lock.version !== LOCK_VERSION) {
+    throw new Error('Invalid system-prompt lock: unsupported version');
+  }
+  if (typeof lock.agentType !== 'string' || typeof lock.installedAt !== 'string') {
+    throw new Error('Invalid system-prompt lock: missing installation metadata');
+  }
+  if (typeof lock.includeAgentsMd !== 'boolean') {
+    throw new Error('Invalid system-prompt lock: includeAgentsMd must be a boolean');
+  }
+  const allowed = new Set(['version', 'agentType', 'installedAt', 'includeAgentsMd', 'generated', ...LOCK_CATEGORIES]);
+  for (const key of Object.keys(lock)) {
+    if (!allowed.has(key)) {
+      throw new Error(`Invalid system-prompt lock: unknown key ${key}`);
+    }
+  }
+  for (const category of LOCK_CATEGORIES) {
+    const entries = lock[category];
+    if (entries === undefined) continue;
+    if (!entries || typeof entries !== 'object' || Array.isArray(entries)) {
+      throw new Error(`Invalid system-prompt lock: invalid ${category} selection`);
+    }
+    const config = categories[category];
+    const knownIds = new Set(config.items.map(item => item.id));
+    for (const [id, entry] of Object.entries(entries)) {
+      if (!knownIds.has(id)) {
+        throw new Error(`Invalid system-prompt lock: unknown ${category} item`);
+      }
+      if (!entry || typeof entry !== 'object' || Array.isArray(entry)) {
+        throw new Error(`Invalid system-prompt lock: invalid ${category} entry`);
+      }
+      if (typeof entry.source !== 'string' || typeof entry.sourceType !== 'string' || typeof entry.itemPath !== 'string') {
+        throw new Error(`Invalid system-prompt lock: invalid ${category} entry source`);
+      }
+      if (!/^[a-f0-9]{64}$/.test(entry.computedHash || '')) {
+        throw new Error(`Invalid system-prompt lock: invalid ${category} entry hash`);
+      }
+      if (!entry.files || typeof entry.files !== 'object' || Array.isArray(entry.files)) {
+        throw new Error(`Invalid system-prompt lock: invalid ${category} entry files`);
+      }
+      for (const [path, checksum] of Object.entries(entry.files)) {
+        if (path.startsWith('/') || path.split('/').includes('..') || !/^[a-f0-9]{64}$/.test(checksum)) {
+          throw new Error('Invalid system-prompt lock: unsafe managed file entry');
+        }
+      }
+    }
+  }
+  const generated = lock.generated;
+  if (generated !== undefined) {
+    if (!generated || typeof generated !== 'object' || Array.isArray(generated)) {
+      throw new Error('Invalid system-prompt lock: generated must be an object');
+    }
+    for (const [path, entry] of Object.entries(generated)) {
+      if (path.startsWith('/') || path.split('/').includes('..') || !/^[a-f0-9]{64}$/.test(entry?.computedHash || '')) {
+        throw new Error('Invalid system-prompt lock: unsafe generated file entry');
+      }
+    }
+  }
+}
+
+export function createLockData({ agentType, includeAgentsMd, selections, managedFiles, fileOwners, source }) {
+  const lockData = {
+    version: LOCK_VERSION,
+    agentType,
+    installedAt: new Date().toISOString(),
+    includeAgentsMd,
+  };
+  for (const category of LOCK_CATEGORIES) {
+    const entries = {};
+    for (const id of selections[category] || []) {
+      if (isRemoved(category, id)) continue;
+      const files = {};
+      for (const [path, checksum] of Object.entries(managedFiles)) {
+        const owner = fileOwners[path];
+        if (owner?.category === category && owner?.id === id) files[path] = checksum;
+      }
+      entries[id] = {
+        source,
+        sourceType: 'bundled',
+        itemPath: itemSourcePath(category, id),
+        computedHash: buildComputedHash(files, id),
+        files,
+      };
+    }
+    lockData[category] = entries;
+  }
+  const generated = {};
+  for (const [path, checksum] of Object.entries(managedFiles)) {
+    if (fileOwners[path]?.generated) generated[path] = { computedHash: checksum };
+  }
+  lockData.generated = generated;
+  return lockData;
+}
+
+export async function writeLockFile(absTarget, lockData) {
+  await writeFile(resolve(absTarget, 'system-prompt-lock.json'), JSON.stringify(lockData, null, 2));
+}
+
+function buildComputedHash(files, fallbackId) {
+  const keys = Object.keys(files).sort();
+  if (keys.length === 0) return hash(fallbackId);
+  if (keys.length === 1) return files[keys[0]];
+  return hash(keys.map(path => `${path}:${files[path]}`).join('\n'));
+}

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

@@ -0,0 +1,31 @@
+import { categories } from './catalog.js';
+
+export const LOCK_CATEGORIES = Object.keys(categories);
+
+export function isFileBased(category) {
+  return categories[category]?.itemLayout === 'file';
+}
+
+export function isCopyable(category) {
+  const config = categories[category];
+  return Boolean(config?.itemLayout) && config.copyItems !== false;
+}
+
+export function targetSubdir(sourceDir) {
+  return sourceDir.replace(/^framework\//, '');
+}
+
+export function itemSourcePath(category, id) {
+  const config = categories[category];
+  return isFileBased(category) ? `${config.sourceDir}/${id}.md` : `${config.sourceDir}/${id}`;
+}
+
+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}`;
+}

package/src/agent-configs.js

@@ -1,100 +0,0 @@
-import { fileURLToPath } from 'node:url';
-import { dirname, resolve } from 'node:path';
-import { readFile } from 'node:fs/promises';
-
-const __dirname = dirname(fileURLToPath(import.meta.url));
-const packageRoot = resolve(__dirname, '..');
-
-export async function loadMcpConfigs(selectedIds) {
-  const entries = {};
-  for (const id of selectedIds) {
-    try {
-      const configPath = resolve(packageRoot, `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 (error.code === 'ENOENT') {
-        console.warn(`  ⚠  No opencode.json config found for MCP: ${id}`);
-        continue;
-      }
-      throw error;
-    }
-  }
-  return entries;
-}
-
-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);
-}
-
-export function generateTuiConfig({ selections }) {
-  const config = {
-    $schema: 'https://opencode.ai/tui.json',
-    theme: 'system',
-    scroll_speed: 3,
-    scroll_acceleration: {
-      enabled: true,
-    },
-    diff_style: 'auto',
-    mouse: true,
-    attention: {
-      enabled: true,
-      notifications: true,
-      sound: true,
-      volume: 0.4,
-    },
-  };
-
-  if (selections.plugins?.includes('opencode-goal-plugin')) {
-    config.plugin = ['@prevalentware/opencode-goal-plugin'];
-  }
-
-  return JSON.stringify(config, null, 4);
-}