sigmap 3.3.1 → 3.3.3

package/packages/adapters/codex.js

@@ -0,0 +1,74 @@
+'use strict';
+
+/**
+ * Codex adapter — writes OpenAI-style context to AGENTS.md.
+ *
+ * This adapter reuses the same prompt format as the OpenAI adapter,
+ * but targets AGENTS.md so Codex-style agents can read repository guidance.
+ *
+ * Contract:
+ *   format(context, opts?) → string
+ *   outputPath(cwd) → string
+ *   write(context, cwd, opts?) → void
+ */
+
+const path = require('path');
+const fs = require('fs');
+const openai = require('./openai');
+
+const name = 'codex';
+const MARKER = '\n\n## Auto-generated signatures\n<!-- Updated by gen-context.js -->\n';
+
+/**
+ * Format context using the OpenAI adapter format.
+ * @param {string} context - Raw signature context string
+ * @param {object} [opts]
+ * @returns {string}
+ */
+function format(context, opts = {}) {
+  return openai.format(context, opts);
+}
+
+/**
+ * Return the output file path for this adapter.
+ * @param {string} cwd - Project root
+ * @returns {string}
+ */
+function outputPath(cwd) {
+  return path.join(cwd, 'AGENTS.md');
+}
+
+/**
+ * Write signatures into AGENTS.md using append-under-marker.
+ * If marker exists, content above marker is preserved.
+ * If legacy generated content exists without marker, replace it cleanly.
+ * @param {string} context - Raw signature context string
+ * @param {string} cwd - Project root
+ * @param {object} [opts]
+ */
+function write(context, cwd, opts = {}) {
+  const filePath = outputPath(cwd);
+  let existing = '';
+  if (fs.existsSync(filePath)) {
+    existing = fs.readFileSync(filePath, 'utf8');
+  }
+
+  const formatted = format(context, opts);
+  const markerIdx = existing.indexOf('## Auto-generated signatures');
+
+  let newContent;
+  if (markerIdx !== -1) {
+    newContent = existing.slice(0, markerIdx) + MARKER.trimStart() + formatted;
+  } else {
+    const isLegacyGenerated = existing.includes('<!-- Generated by SigMap gen-context.js')
+      || existing.includes('## Code Signatures')
+      || existing.includes('# Code signatures');
+    newContent = isLegacyGenerated
+      ? MARKER.trimStart() + formatted
+      : existing + MARKER + formatted;
+  }
+
+  fs.writeFileSync(filePath, newContent, 'utf8');
+}
+
+module.exports = { name, format, outputPath, write };

package/packages/adapters/copilot.js

@@ -10,8 +10,10 @@
  */
 
 const path = require('path');
+const fs = require('fs');
 
 const name = 'copilot';
+const MARKER = '\n\n## Auto-generated signatures\n<!-- Updated by gen-context.js -->\n';
 
 /**
  * Format context for GitHub Copilot instructions.
@@ -44,4 +46,37 @@ function outputPath(cwd) {
   return path.join(cwd, '.github', 'copilot-instructions.md');
 }
 
-module.exports = { name, format, outputPath };
+/**
+ * Write signatures into copilot-instructions.md using append-under-marker.
+ * If marker exists, content above marker is preserved.
+ * If legacy generated content exists without marker, replace it cleanly.
+ * @param {string} context - Raw signature context string
+ * @param {string} cwd - Project root
+ * @param {object} [opts]
+ */
+function write(context, cwd, opts = {}) {
+  const filePath = outputPath(cwd);
+  let existing = '';
+  if (fs.existsSync(filePath)) {
+    existing = fs.readFileSync(filePath, 'utf8');
+  }
+
+  const formatted = format(context, opts);
+  const markerIdx = existing.indexOf('## Auto-generated signatures');
+
+  let newContent;
+  if (markerIdx !== -1) {
+    newContent = existing.slice(0, markerIdx) + MARKER.trimStart() + formatted;
+  } else {
+    const isLegacyGenerated = existing.includes('<!-- Generated by SigMap gen-context.js')
+      || existing.includes('# Code signatures');
+    newContent = isLegacyGenerated
+      ? MARKER.trimStart() + formatted
+      : existing + MARKER + formatted;
+  }
+
+  fs.mkdirSync(path.dirname(filePath), { recursive: true });
+  fs.writeFileSync(filePath, newContent, 'utf8');
+}
+
+module.exports = { name, format, outputPath, write };

package/packages/adapters/gemini.js

@@ -15,8 +15,10 @@
  */
 
 const path = require('path');
+const fs = require('fs');
 
 const name = 'gemini';
+const MARKER = '\n\n## Auto-generated signatures\n<!-- Updated by gen-context.js -->\n';
 
 /**
  * Format context as a Gemini system instruction.
@@ -56,4 +58,37 @@ function outputPath(cwd) {
   return path.join(cwd, '.github', 'gemini-context.md');
 }
 
-module.exports = { name, format, outputPath };
+/**
+ * Write signatures into gemini-context.md using append-under-marker.
+ * If marker exists, content above marker is preserved.
+ * If legacy generated content exists without marker, replace it cleanly.
+ * @param {string} context - Raw signature context string
+ * @param {string} cwd - Project root
+ * @param {object} [opts]
+ */
+function write(context, cwd, opts = {}) {
+  const filePath = outputPath(cwd);
+  let existing = '';
+  if (fs.existsSync(filePath)) {
+    existing = fs.readFileSync(filePath, 'utf8');
+  }
+
+  const formatted = format(context, opts);
+  const markerIdx = existing.indexOf('## Auto-generated signatures');
+
+  let newContent;
+  if (markerIdx !== -1) {
+    newContent = existing.slice(0, markerIdx) + MARKER.trimStart() + formatted;
+  } else {
+    const isLegacyGenerated = existing.includes('<!-- Generated by SigMap gen-context.js')
+      || existing.includes('## Code Signatures');
+    newContent = isLegacyGenerated
+      ? MARKER.trimStart() + formatted
+      : existing + MARKER + formatted;
+  }
+
+  fs.mkdirSync(path.dirname(filePath), { recursive: true });
+  fs.writeFileSync(filePath, newContent, 'utf8');
+}
+
+module.exports = { name, format, outputPath, write };

package/packages/adapters/index.js

@@ -11,14 +11,14 @@
 
 const path = require('path');
 
-const ADAPTER_NAMES = ['copilot', 'claude', 'cursor', 'windsurf', 'openai', 'gemini'];
+const ADAPTER_NAMES = ['copilot', 'claude', 'cursor', 'windsurf', 'openai', 'gemini', 'codex'];
 
 // Lazy-load adapters so unused ones don't pay any require() cost
 const _cache = {};
 
 /**
  * Load and return an adapter module by name.
- * @param {string} name - Adapter name (copilot|claude|cursor|windsurf|openai|gemini)
+ * @param {string} name - Adapter name (copilot|claude|cursor|windsurf|openai|gemini|codex)
  * @returns {{ name: string, format: Function, outputPath: Function }|null}
  */
 function getAdapter(name) {

package/packages/cli/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sigmap-cli",
-  "version": "3.3.1",
+  "version": "3.3.3",
   "description": "SigMap CLI wrapper — thin adapter for programmatic CLI invocation",
   "main": "index.js",
   "keywords": [

package/packages/core/index.js

@@ -35,6 +35,11 @@ const EXT_MAP = {
   '.css': 'css',       '.scss': 'css', '.sass': 'css', '.less': 'css',
   '.yml': 'yaml',      '.yaml': 'yaml',
   '.sh': 'shell',      '.bash': 'shell', '.zsh': 'shell', '.fish': 'shell',
+  // P1 languages
+  '.sql': 'sql',
+  '.graphql': 'graphql', '.gql': 'graphql',
+  '.tf': 'terraform', '.tfvars': 'terraform',
+  '.proto': 'protobuf',
 };
 
 const SRC_ROOT = path.resolve(__dirname, '..', '..', 'src');

package/packages/core/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sigmap-core",
-  "version": "3.3.1",
+  "version": "3.3.3",
   "description": "SigMap core library — zero-dependency code signature extraction, retrieval, and security scanning",
   "main": "index.js",
   "keywords": [

package/src/config/loader.js

@@ -7,6 +7,142 @@ const { DEFAULTS } = require('./defaults');
 // Keys that are valid in gen-context.config.json
 const KNOWN_KEYS = new Set(Object.keys(DEFAULTS));
 
+// Common top-level folder names that reliably hold source code
+const COMMON_CODE_DIRS = new Set([
+  'src', 'app', 'lib', 'packages', 'services', 'api', 'core', 'cmd',
+  'internal', 'pkg', 'handlers', 'controllers', 'models', 'views',
+  'components', 'pages', 'routes', 'middleware', 'utils', 'helpers',
+  'modules', 'plugins', 'extensions', 'adapters', 'drivers',
+  'examples', 'sample', 'demo', 'tests', 'test', 'spec', '__tests__',
+  'hooks', 'composables', 'stores', 'features', 'domain', 'infra',
+  'infrastructure', 'application', 'data', 'Sources', 'Tests',
+]);
+
+const SUPPORTED_CODE_EXTS = new Set([
+  '.ts', '.tsx', '.js', '.jsx', '.mjs', '.cjs',
+  '.py', '.pyw', '.java', '.kt', '.kts', '.go', '.rs', '.cs',
+  '.cpp', '.c', '.h', '.hpp', '.cc', '.rb', '.rake', '.php',
+  '.swift', '.dart', '.scala', '.sc', '.vue', '.svelte',
+  '.html', '.htm', '.css', '.scss', '.sass', '.less',
+  '.yml', '.yaml', '.sh', '.bash', '.zsh', '.fish',
+  '.sql', '.graphql', '.gql', '.tf', '.tfvars', '.proto',
+]);
+
+/**
+ * Detect source directories for the given project root by reading manifest
+ * files and scanning top-level directories for code files.
+ *
+ * @param {string} cwd - Project root
+ * @param {string[]} excludeList - Folders to skip
+ * @returns {string[]}
+ */
+function detectAutoSrcDirs(cwd, excludeList) {
+  const excludeSet = new Set(excludeList || []);
+  const candidates = new Set(DEFAULTS.srcDirs);
+
+  // ── Manifest-based detection ──────────────────────────────────────────────
+  const pkgPath = path.join(cwd, 'package.json');
+  if (fs.existsSync(pkgPath)) {
+    try {
+      const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf8'));
+      const allDeps = { ...pkg.dependencies, ...pkg.devDependencies, ...pkg.peerDependencies };
+      if (allDeps.react || allDeps.next) {
+        for (const d of ['src', 'app', 'pages', 'components', 'hooks', 'lib', 'utils']) candidates.add(d);
+      }
+      if (allDeps['@angular/core']) {
+        for (const d of ['src', 'projects', 'apps', 'libs']) candidates.add(d);
+      }
+      if (allDeps['@nestjs/core']) {
+        for (const d of ['src', 'libs', 'apps']) candidates.add(d);
+      }
+      if (allDeps.vue) {
+        for (const d of ['src', 'components', 'views', 'stores', 'composables', 'plugins']) candidates.add(d);
+      }
+      if (allDeps.svelte || allDeps['@sveltejs/kit']) {
+        for (const d of ['src', 'lib', 'routes']) candidates.add(d);
+      }
+      if (allDeps.nx || allDeps.turbo || allDeps.lerna || pkg.workspaces) {
+        for (const d of ['packages', 'apps', 'libs', 'services']) candidates.add(d);
+      }
+    } catch (_) {}
+  }
+
+  const hasPyproject = fs.existsSync(path.join(cwd, 'pyproject.toml'));
+  const hasRequirements = fs.existsSync(path.join(cwd, 'requirements.txt'));
+  const hasSetupPy = fs.existsSync(path.join(cwd, 'setup.py'));
+  if (hasPyproject || hasRequirements || hasSetupPy) {
+    for (const d of ['src', 'app', 'tests', 'examples']) candidates.add(d);
+  }
+
+  if (fs.existsSync(path.join(cwd, 'Gemfile'))) {
+    for (const d of ['app', 'lib', 'config', 'db', 'spec', 'test']) candidates.add(d);
+  }
+
+  if (fs.existsSync(path.join(cwd, 'composer.json'))) {
+    for (const d of ['app', 'resources', 'routes', 'database', 'tests']) candidates.add(d);
+  }
+
+  if (fs.existsSync(path.join(cwd, 'go.mod'))) {
+    for (const d of ['cmd', 'internal', 'pkg', 'api', 'handler', 'handlers', 'middleware', 'service']) candidates.add(d);
+  }
+
+  if (fs.existsSync(path.join(cwd, 'Cargo.toml'))) {
+    for (const d of ['src', 'crates', 'examples', 'tests', 'benches']) candidates.add(d);
+  }
+
+  const hasGradle = fs.existsSync(path.join(cwd, 'build.gradle')) ||
+                    fs.existsSync(path.join(cwd, 'build.gradle.kts'));
+  const hasMaven = fs.existsSync(path.join(cwd, 'pom.xml'));
+  if (hasGradle || hasMaven) {
+    for (const d of [
+      'src/main/java', 'src/main/kotlin', 'src/main/scala',
+      'src/main/resources', 'src/test/java', 'src/test/kotlin',
+    ]) candidates.add(d);
+  }
+
+  if (fs.existsSync(path.join(cwd, 'pubspec.yaml'))) {
+    for (const d of ['lib', 'test', 'integration_test', 'example', 'bin']) candidates.add(d);
+  }
+
+  if (fs.existsSync(path.join(cwd, 'Package.swift'))) {
+    for (const d of ['Sources', 'Tests']) candidates.add(d);
+  }
+
+  // ── Top-level directory scan ──────────────────────────────────────────────
+  try {
+    const entries = fs.readdirSync(cwd, { withFileTypes: true });
+    for (const entry of entries) {
+      if (!entry.isDirectory()) continue;
+      if (entry.name.startsWith('.')) continue;
+      if (excludeSet.has(entry.name)) continue;
+
+      const lname = entry.name.toLowerCase();
+      if (COMMON_CODE_DIRS.has(entry.name) || COMMON_CODE_DIRS.has(lname)) {
+        candidates.add(entry.name);
+        continue;
+      }
+      // Unknown dir: add if it directly contains source files
+      const dirPath = path.join(cwd, entry.name);
+      try {
+        const subs = fs.readdirSync(dirPath, { withFileTypes: true });
+        const hasSrc = subs.some((s) => {
+          if (!s.isFile()) return false;
+          return SUPPORTED_CODE_EXTS.has(path.extname(s.name).toLowerCase()) || s.name === 'Dockerfile';
+        });
+        if (hasSrc) { candidates.add(entry.name); continue; }
+        const hasSrcSub = subs.some((s) =>
+          s.isDirectory() && ['src', 'lib', 'main', 'java', 'kotlin', 'scala', 'python'].includes(s.name));
+        if (hasSrcSub) candidates.add(entry.name);
+      } catch (_) {}
+    }
+  } catch (_) {}
+
+  // Only return those that exist
+  return Array.from(candidates).filter((d) => {
+    try { return fs.statSync(path.join(cwd, d)).isDirectory(); } catch (_) { return false; }
+  });
+}
+
 /**
  * Load and merge configuration for a given working directory.
  *
@@ -16,7 +152,10 @@ const KNOWN_KEYS = new Set(Object.keys(DEFAULTS));
 function loadConfig(cwd) {
   const configPath = path.join(cwd, 'gen-context.config.json');
   if (!fs.existsSync(configPath)) {
-    return deepClone(DEFAULTS);
+    const cfg = deepClone(DEFAULTS);
+    const detected = detectAutoSrcDirs(cwd, cfg.exclude);
+    if (detected.length > 0) cfg.srcDirs = detected;
+    return cfg;
   }
 
   let userConfig;
@@ -25,7 +164,10 @@ function loadConfig(cwd) {
     userConfig = JSON.parse(raw);
   } catch (err) {
     console.warn(`[sigmap] config parse error in ${configPath}: ${err.message}`);
-    return deepClone(DEFAULTS);
+    const cfg = deepClone(DEFAULTS);
+    const detected = detectAutoSrcDirs(cwd, cfg.exclude);
+    if (detected.length > 0) cfg.srcDirs = detected;
+    return cfg;
   }
 
   // Warn on unknown keys (helps catch typos)
@@ -50,6 +192,13 @@ function loadConfig(cwd) {
       merged[key] = val;
     }
   }
+
+  // If user didn't specify srcDirs, auto-detect; fall back to DEFAULTS if nothing found
+  if (!Array.isArray(userConfig.srcDirs)) {
+    const detected = detectAutoSrcDirs(cwd, merged.exclude);
+    merged.srcDirs = detected.length > 0 ? detected : deepClone(DEFAULTS.srcDirs);
+  }
+
   // Backward compat (v3.0+): mirror outputs ↔ adapters
   if (merged.adapters && !Array.isArray(merged.adapters)) merged.adapters = null;
   if (!merged.adapters && Array.isArray(merged.outputs)) {

package/src/extractors/graphql.js

@@ -0,0 +1,66 @@
+'use strict';
+
+/**
+ * Extract signatures from GraphQL schema / operation files.
+ * Captures type, interface, enum, input, union, scalar, query, mutation,
+ * subscription, fragment definitions.
+ *
+ * @param {string} src - Raw GraphQL content
+ * @returns {string[]} Array of signature strings
+ */
+function extract(src) {
+  if (!src || typeof src !== 'string') return [];
+  const sigs = [];
+
+  // Strip comments (# style)
+  const stripped = src.replace(/#[^\n]*/g, '');
+
+  // Schema type definitions: type Foo [implements Bar] { ... }
+  for (const m of stripped.matchAll(
+    /\b(type|interface|input)\s+(\w+)(?:\s+implements\s+([\w\s&]+))?\s*\{/g
+  )) {
+    const implements_ = m[3] ? ` implements ${m[3].trim().replace(/\s+/g, ' ')}` : '';
+    sigs.push(`${m[1]} ${m[2]}${implements_}`);
+  }
+
+  // enum
+  for (const m of stripped.matchAll(/\benum\s+(\w+)\s*\{/g)) {
+    sigs.push(`enum ${m[1]}`);
+  }
+
+  // union
+  for (const m of stripped.matchAll(/\bunion\s+(\w+)\s*=/g)) {
+    sigs.push(`union ${m[1]}`);
+  }
+
+  // scalar
+  for (const m of stripped.matchAll(/\bscalar\s+(\w+)/g)) {
+    sigs.push(`scalar ${m[1]}`);
+  }
+
+  // extend type / extend interface
+  for (const m of stripped.matchAll(/\bextend\s+(type|interface)\s+(\w+)/g)) {
+    sigs.push(`extend ${m[1]} ${m[2]}`);
+  }
+
+  // Query / Mutation / Subscription operations
+  for (const m of stripped.matchAll(
+    /\b(query|mutation|subscription)\s+(\w+)\s*(?:\([^)]*\))?\s*\{/g
+  )) {
+    sigs.push(`${m[1]} ${m[2]}`);
+  }
+
+  // Named fragments
+  for (const m of stripped.matchAll(/\bfragment\s+(\w+)\s+on\s+(\w+)/g)) {
+    sigs.push(`fragment ${m[1]} on ${m[2]}`);
+  }
+
+  // Top-level schema { query: ... }
+  if (/\bschema\s*\{/.test(stripped)) {
+    sigs.push('schema { ... }');
+  }
+
+  return sigs;
+}
+
+module.exports = { extract };

package/src/extractors/protobuf.js

@@ -0,0 +1,63 @@
+'use strict';
+
+/**
+ * Extract signatures from Protocol Buffer (.proto) files.
+ * Captures message, enum, service, rpc, oneof, extend definitions.
+ *
+ * @param {string} src - Raw .proto content
+ * @returns {string[]} Array of signature strings
+ */
+function extract(src) {
+  if (!src || typeof src !== 'string') return [];
+  const sigs = [];
+
+  // Strip single-line and block comments
+  const stripped = src
+    .replace(/\/\/[^\n]*/g, '')
+    .replace(/\/\*[\s\S]*?\*\//g, '');
+
+  // syntax / package / option (top-level metadata)
+  const syntaxM = stripped.match(/\bsyntax\s*=\s*"([^"]+)"/);
+  if (syntaxM) sigs.push(`syntax = "${syntaxM[1]}"`);
+
+  const pkgM = stripped.match(/\bpackage\s+([\w.]+)\s*;/);
+  if (pkgM) sigs.push(`package ${pkgM[1]}`);
+
+  // message <Name> { ... }
+  for (const m of stripped.matchAll(/\bmessage\s+(\w+)\s*\{/g)) {
+    sigs.push(`message ${m[1]}`);
+  }
+
+  // enum <Name> { ... }
+  for (const m of stripped.matchAll(/\benum\s+(\w+)\s*\{/g)) {
+    sigs.push(`enum ${m[1]}`);
+  }
+
+  // service <Name> { ... }
+  for (const m of stripped.matchAll(/\bservice\s+(\w+)\s*\{/g)) {
+    sigs.push(`service ${m[1]}`);
+  }
+
+  // rpc <Name>(<Request>) returns (<Response>)
+  for (const m of stripped.matchAll(
+    /\brpc\s+(\w+)\s*\(\s*(stream\s+)?(\w+)\s*\)\s+returns\s*\(\s*(stream\s+)?(\w+)\s*\)/g
+  )) {
+    const req = `${m[2] || ''}${m[3]}`.trim();
+    const res = `${m[4] || ''}${m[5]}`.trim();
+    sigs.push(`rpc ${m[1]}(${req}) returns (${res})`);
+  }
+
+  // oneof <name>
+  for (const m of stripped.matchAll(/\boneof\s+(\w+)\s*\{/g)) {
+    sigs.push(`oneof ${m[1]}`);
+  }
+
+  // extend <TypeName>
+  for (const m of stripped.matchAll(/\bextend\s+([\w.]+)\s*\{/g)) {
+    sigs.push(`extend ${m[1]}`);
+  }
+
+  return sigs;
+}
+
+module.exports = { extract };

package/src/extractors/sql.js

@@ -0,0 +1,93 @@
+'use strict';
+
+/**
+ * Extract signatures from SQL source files.
+ * Captures CREATE TABLE, VIEW, INDEX, FUNCTION, PROCEDURE, TRIGGER, TYPE, SEQUENCE.
+ *
+ * @param {string} src - Raw SQL content
+ * @returns {string[]} Array of signature strings
+ */
+function extract(src) {
+  if (!src || typeof src !== 'string') return [];
+  const sigs = [];
+
+  // Strip single-line comments and block comments
+  const stripped = src
+    .replace(/--[^\n]*/g, '')
+    .replace(/\/\*[\s\S]*?\*\//g, '');
+
+  // CREATE TABLE [IF NOT EXISTS] <name> / CREATE [TEMP] TABLE ...
+  for (const m of stripped.matchAll(
+    /CREATE\s+(?:OR\s+REPLACE\s+)?(?:TEMP(?:ORARY)?\s+)?TABLE\s+(?:IF\s+NOT\s+EXISTS\s+)?([`"[\w.]+)/gi
+  )) {
+    sigs.push(`TABLE ${_cleanName(m[1])}`);
+  }
+
+  // CREATE VIEW / MATERIALIZED VIEW
+  for (const m of stripped.matchAll(
+    /CREATE\s+(?:OR\s+REPLACE\s+)?(?:MATERIALIZED\s+)?VIEW\s+(?:IF\s+NOT\s+EXISTS\s+)?([`"[\w.]+)/gi
+  )) {
+    sigs.push(`VIEW ${_cleanName(m[1])}`);
+  }
+
+  // CREATE INDEX / UNIQUE INDEX
+  for (const m of stripped.matchAll(
+    /CREATE\s+(?:UNIQUE\s+)?INDEX\s+(?:CONCURRENTLY\s+)?(?:IF\s+NOT\s+EXISTS\s+)?([`"[\w.]+)\s+ON\s+([`"[\w.]+)/gi
+  )) {
+    sigs.push(`INDEX ${_cleanName(m[1])} ON ${_cleanName(m[2])}`);
+  }
+
+  // CREATE FUNCTION / CREATE OR REPLACE FUNCTION
+  for (const m of stripped.matchAll(
+    /CREATE\s+(?:OR\s+REPLACE\s+)?FUNCTION\s+([`"[\w.]+)\s*\(([^)]*)\)/gi
+  )) {
+    const params = _normalizeParams(m[2]);
+    sigs.push(`FUNCTION ${_cleanName(m[1])}(${params})`);
+  }
+
+  // CREATE PROCEDURE
+  for (const m of stripped.matchAll(
+    /CREATE\s+(?:OR\s+REPLACE\s+)?PROCEDURE\s+([`"[\w.]+)\s*\(([^)]*)\)/gi
+  )) {
+    const params = _normalizeParams(m[2]);
+    sigs.push(`PROCEDURE ${_cleanName(m[1])}(${params})`);
+  }
+
+  // CREATE TRIGGER
+  for (const m of stripped.matchAll(
+    /CREATE\s+(?:OR\s+REPLACE\s+)?(?:CONSTRAINT\s+)?TRIGGER\s+([`"[\w.]+)/gi
+  )) {
+    sigs.push(`TRIGGER ${_cleanName(m[1])}`);
+  }
+
+  // CREATE TYPE (composite, enum, domain)
+  for (const m of stripped.matchAll(
+    /CREATE\s+(?:OR\s+REPLACE\s+)?TYPE\s+([`"[\w.]+)/gi
+  )) {
+    sigs.push(`TYPE ${_cleanName(m[1])}`);
+  }
+
+  // CREATE SEQUENCE
+  for (const m of stripped.matchAll(
+    /CREATE\s+(?:OR\s+REPLACE\s+)?SEQUENCE\s+(?:IF\s+NOT\s+EXISTS\s+)?([`"[\w.]+)/gi
+  )) {
+    sigs.push(`SEQUENCE ${_cleanName(m[1])}`);
+  }
+
+  return sigs;
+}
+
+function _cleanName(raw) {
+  return raw.replace(/^[`"[]|[`"\]]+$/g, '').trim();
+}
+
+function _normalizeParams(raw) {
+  if (!raw || !raw.trim()) return '';
+  return raw.trim()
+    .split(',')
+    .map((p) => p.trim().replace(/\s+/g, ' ').split(' ').slice(0, 2).join(' '))
+    .filter(Boolean)
+    .join(', ');
+}
+
+module.exports = { extract };