agentsys 5.0.0

package/plugins/audit-project/lib/repo-map/installer.js

@@ -0,0 +1,212 @@
+/**
+ * ast-grep installation detection and helpers
+ *
+ * @module lib/repo-map/installer
+ */
+
+'use strict';
+
+const { execSync, execFileSync, execFile } = require('child_process');
+const fs = require('fs');
+const path = require('path');
+const { promisify } = require('util');
+
+const execFileAsync = promisify(execFile);
+
+// Commands to try (sg is the common alias)
+const AST_GREP_COMMANDS = ['sg', 'ast-grep'];
+
+function pickCommandPath(pathOutput) {
+  if (!pathOutput) return null;
+  const candidates = pathOutput.split(/\r?\n/).map(line => line.trim()).filter(Boolean);
+  if (candidates.length === 0) return null;
+
+  if (process.platform !== 'win32') {
+    return candidates[0];
+  }
+
+  const exe = candidates.find(candidate => candidate.toLowerCase().endsWith('.exe'));
+  if (exe) return exe;
+
+  const primary = candidates[0];
+  if (!primary) return null;
+
+  const baseDir = path.dirname(primary);
+  const npmExe = path.join(baseDir, 'node_modules', '@ast-grep', 'cli', 'sg.exe');
+  if (fs.existsSync(npmExe)) return npmExe;
+
+  return primary;
+}
+
+/**
+ * Check if ast-grep is installed
+ * @returns {Promise<{found: boolean, version?: string, path?: string, command?: string}>}
+ */
+async function checkInstalled() {
+  for (const cmd of AST_GREP_COMMANDS) {
+    try {
+      // Try to get version using execFileAsync (no shell, safe from injection)
+      const { stdout } = await execFileAsync(cmd, ['--version'], {
+        timeout: 5000,
+        windowsHide: true,
+        shell: process.platform === 'win32' // Windows needs shell for PATH lookup
+      });
+
+      const version = stdout.trim().replace(/^ast-grep\s*/i, '');
+
+      // Try to get path
+      let cmdPath = null;
+      try {
+        const whereCmd = process.platform === 'win32' ? 'where' : 'which';
+        // Use execFileAsync with args array (no shell interpolation)
+        const { stdout: pathOut } = await execFileAsync(whereCmd, [cmd], {
+          timeout: 5000,
+          windowsHide: true,
+          shell: process.platform === 'win32'
+        });
+        cmdPath = pickCommandPath(pathOut);
+      } catch {
+        // Path lookup failed, but command works
+      }
+
+      return {
+        found: true,
+        version,
+        path: cmdPath,
+        command: cmdPath || cmd
+      };
+    } catch {
+      // This command not found, try next
+      continue;
+    }
+  }
+
+  return { found: false };
+}
+
+/**
+ * Check if ast-grep is installed (sync version)
+ * @returns {{found: boolean, version?: string, command?: string, path?: string}}
+ */
+function checkInstalledSync() {
+  for (const cmd of AST_GREP_COMMANDS) {
+    try {
+      // Use execFileSync with args array (no shell interpolation, safe from injection)
+      const stdout = execFileSync(cmd, ['--version'], {
+        timeout: 5000,
+        windowsHide: true,
+        encoding: 'utf8',
+        stdio: ['pipe', 'pipe', 'pipe'],
+        shell: process.platform === 'win32' // Windows needs shell for PATH lookup
+      });
+
+      const version = stdout.trim().replace(/^ast-grep\s*/i, '');
+      let cmdPath = null;
+
+      try {
+        const whereCmd = process.platform === 'win32' ? 'where' : 'which';
+        // Use execFileSync with args array (no shell interpolation)
+        const pathOut = execFileSync(whereCmd, [cmd], {
+          timeout: 5000,
+          windowsHide: true,
+          encoding: 'utf8',
+          stdio: ['pipe', 'pipe', 'pipe'],
+          shell: process.platform === 'win32'
+        });
+        cmdPath = pickCommandPath(pathOut);
+      } catch {
+        // Path lookup failed, but command works
+      }
+
+      return { found: true, version, command: cmdPath || cmd, path: cmdPath };
+    } catch {
+      continue;
+    }
+  }
+
+  return { found: false };
+}
+
+/**
+ * Get the working ast-grep command
+ * @returns {string|null}
+ */
+function getCommand() {
+  const result = checkInstalledSync();
+  return result.found ? result.command : null;
+}
+
+/**
+ * Get installation instructions for ast-grep
+ * @returns {string}
+ */
+function getInstallInstructions() {
+  return `ast-grep (sg) is required for repo-map functionality.
+
+Install using one of these methods:
+
+  npm:      npm install -g @ast-grep/cli
+  pip:      pip install ast-grep-cli
+  brew:     brew install ast-grep
+  cargo:    cargo install ast-grep --locked
+  scoop:    scoop install main/ast-grep
+
+After installation, verify with: sg --version
+
+Documentation: https://ast-grep.github.io/`;
+}
+
+/**
+ * Get a short install suggestion (one line)
+ * @returns {string}
+ */
+function getShortInstallSuggestion() {
+  if (process.platform === 'win32') {
+    return 'Install ast-grep: npm i -g @ast-grep/cli (or scoop install ast-grep)';
+  } else if (process.platform === 'darwin') {
+    return 'Install ast-grep: brew install ast-grep (or npm i -g @ast-grep/cli)';
+  } else {
+    return 'Install ast-grep: npm i -g @ast-grep/cli (or pip install ast-grep-cli)';
+  }
+}
+
+/**
+ * Get minimum required version
+ * @returns {string}
+ */
+function getMinimumVersion() {
+  return '0.20.0'; // Require at least this version for JSON output support
+}
+
+/**
+ * Check if installed version meets minimum requirements
+ * @param {string} version - Installed version
+ * @returns {boolean}
+ */
+function meetsMinimumVersion(version) {
+  if (!version) return false;
+
+  // Parse version (e.g., "0.25.0" or "0.25.0-beta.1")
+  const match = version.match(/^(\d+)\.(\d+)\.(\d+)/);
+  if (!match) return false;
+
+  const [, major, minor, patch] = match.map(Number);
+  const [reqMajor, reqMinor, reqPatch] = getMinimumVersion().split('.').map(Number);
+
+  if (major > reqMajor) return true;
+  if (major < reqMajor) return false;
+  if (minor > reqMinor) return true;
+  if (minor < reqMinor) return false;
+  return patch >= reqPatch;
+}
+
+module.exports = {
+  checkInstalled,
+  checkInstalledSync,
+  getCommand,
+  getInstallInstructions,
+  getShortInstallSuggestion,
+  getMinimumVersion,
+  meetsMinimumVersion,
+  AST_GREP_COMMANDS
+};

package/plugins/audit-project/lib/repo-map/queries/go.js

@@ -0,0 +1,27 @@
+/**
+ * Go query patterns for ast-grep
+ */
+
+'use strict';
+
+module.exports = {
+  exports: [],
+  functions: [
+    { pattern: 'func $NAME($$$) { $$$ }', nameVar: 'NAME' },
+    { pattern: 'func ($$$) $NAME($$$) { $$$ }', nameVar: 'NAME' }
+  ],
+  classes: [],
+  types: [
+    { pattern: 'type $NAME struct { $$$ }', nameVar: 'NAME' },
+    { pattern: 'type $NAME interface { $$$ }', nameVar: 'NAME' },
+    { pattern: 'type $NAME = $$$', nameVar: 'NAME' }
+  ],
+  constants: [
+    { pattern: 'const $NAME = $$$', nameVar: 'NAME' },
+    { pattern: 'const $NAME $TYPE = $$$', nameVar: 'NAME' }
+  ],
+  imports: [
+    { pattern: 'import $SOURCE', sourceVar: 'SOURCE', kind: 'import' },
+    { pattern: 'import $NAME $SOURCE', sourceVar: 'SOURCE', kind: 'import' }
+  ]
+};

package/plugins/audit-project/lib/repo-map/queries/index.js

@@ -0,0 +1,100 @@
+/**
+ * Language-specific query patterns for ast-grep
+ *
+ * @module lib/repo-map/queries
+ */
+
+'use strict';
+
+const path = require('path');
+
+const javascript = require('./javascript');
+const typescript = require('./typescript');
+const python = require('./python');
+const rust = require('./rust');
+const go = require('./go');
+const java = require('./java');
+
+/**
+ * Get query patterns for a language
+ * @param {string} language - Language name
+ * @returns {Object|null}
+ */
+function getQueriesForLanguage(language) {
+  switch (language) {
+    case 'javascript':
+    case 'js':
+    case 'node':
+      return javascript;
+    case 'typescript':
+    case 'ts':
+      return typescript;
+    case 'python':
+    case 'py':
+      return python;
+    case 'rust':
+      return rust;
+    case 'go':
+      return go;
+    case 'java':
+      return java;
+    default:
+      return null;
+  }
+}
+
+/**
+ * Get base ast-grep language identifier
+ * @param {string} language - Language name
+ * @returns {string}
+ */
+function getSgLanguage(language) {
+  switch (language) {
+    case 'javascript':
+    case 'js':
+    case 'node':
+      return 'javascript';
+    case 'typescript':
+    case 'ts':
+      return 'typescript';
+    case 'python':
+    case 'py':
+      return 'python';
+    case 'rust':
+      return 'rust';
+    case 'go':
+      return 'go';
+    case 'java':
+      return 'java';
+    default:
+      return 'javascript';
+  }
+}
+
+/**
+ * Get ast-grep language identifier based on file extension
+ * @param {string} filePath - File path
+ * @param {string} language - Language name
+ * @returns {string}
+ */
+function getSgLanguageForFile(filePath, language) {
+  const ext = path.extname(filePath).toLowerCase();
+
+  if (language === 'javascript') {
+    if (ext === '.jsx') return 'jsx';
+    return 'javascript';
+  }
+
+  if (language === 'typescript') {
+    if (ext === '.tsx') return 'tsx';
+    return 'typescript';
+  }
+
+  return getSgLanguage(language);
+}
+
+module.exports = {
+  getQueriesForLanguage,
+  getSgLanguage,
+  getSgLanguageForFile
+};

package/plugins/audit-project/lib/repo-map/queries/java.js

@@ -0,0 +1,38 @@
+/**
+ * Java query patterns for ast-grep
+ */
+
+'use strict';
+
+module.exports = {
+  exports: [
+    { pattern: 'public class $NAME { $$$ }', kind: 'class', nameVar: 'NAME' },
+    { pattern: 'public interface $NAME { $$$ }', kind: 'class', nameVar: 'NAME' },
+    { pattern: 'public enum $NAME { $$$ }', kind: 'class', nameVar: 'NAME' },
+    { pattern: 'public record $NAME($$$) { $$$ }', kind: 'class', nameVar: 'NAME' },
+    { pattern: 'public $RET $NAME($$$) { $$$ }', kind: 'function', nameVar: 'NAME' },
+    { pattern: 'public static $RET $NAME($$$) { $$$ }', kind: 'function', nameVar: 'NAME' },
+    { pattern: 'public $RET $NAME($$$);', kind: 'function', nameVar: 'NAME' }
+  ],
+  functions: [
+    { pattern: 'public $RET $NAME($$$) { $$$ }', nameVar: 'NAME' },
+    { pattern: 'public static $RET $NAME($$$) { $$$ }', nameVar: 'NAME' },
+    { pattern: 'protected $RET $NAME($$$) { $$$ }', nameVar: 'NAME' },
+    { pattern: 'private $RET $NAME($$$) { $$$ }', nameVar: 'NAME' }
+  ],
+  classes: [
+    { pattern: 'class $NAME { $$$ }', nameVar: 'NAME' },
+    { pattern: 'interface $NAME { $$$ }', nameVar: 'NAME' },
+    { pattern: 'enum $NAME { $$$ }', nameVar: 'NAME' },
+    { pattern: 'record $NAME($$$) { $$$ }', nameVar: 'NAME' }
+  ],
+  types: [],
+  constants: [
+    { pattern: 'public static final $TYPE $NAME = $$$;', nameVar: 'NAME' },
+    { pattern: 'static final $TYPE $NAME = $$$;', nameVar: 'NAME' }
+  ],
+  imports: [
+    { pattern: 'import $SOURCE;', sourceVar: 'SOURCE', kind: 'import' },
+    { pattern: 'import static $SOURCE;', sourceVar: 'SOURCE', kind: 'import' }
+  ]
+};

package/plugins/audit-project/lib/repo-map/queries/javascript.js

@@ -0,0 +1,55 @@
+/**
+ * JavaScript query patterns for ast-grep
+ */
+
+'use strict';
+
+module.exports = {
+  exports: [
+    { pattern: 'export function $NAME($$$) { $$$ }', kind: 'function', nameVar: 'NAME' },
+    { pattern: 'export async function $NAME($$$) { $$$ }', kind: 'function', nameVar: 'NAME' },
+    { pattern: 'export class $NAME { $$$ }', kind: 'class', nameVar: 'NAME' },
+    { pattern: 'export const $NAME = $$$', kind: 'constant', nameVar: 'NAME' },
+    { pattern: 'export let $NAME = $$$', kind: 'variable', nameVar: 'NAME' },
+    { pattern: 'export var $NAME = $$$', kind: 'variable', nameVar: 'NAME' },
+    { pattern: 'export default function $NAME($$$) { $$$ }', kind: 'function', nameVar: 'NAME' },
+    { pattern: 'export default class $NAME { $$$ }', kind: 'class', nameVar: 'NAME' },
+    { pattern: 'export default function ($$$) { $$$ }', kind: 'function', fallbackName: 'default' },
+    { pattern: 'export default class { $$$ }', kind: 'class', fallbackName: 'default' },
+    { pattern: 'export default $NAME', kind: 'value', nameVar: 'NAME' },
+    { pattern: 'export { $$$ }', kind: 'value', multi: 'exportList' },
+    { pattern: 'export { $$$ } from $SOURCE', kind: 're-export', multi: 'exportList', sourceVar: 'SOURCE' },
+    { pattern: 'export * from $SOURCE', kind: 're-export', fallbackName: '*', sourceVar: 'SOURCE' },
+    { pattern: 'module.exports = $NAME', kind: 'value', nameVar: 'NAME' },
+    { pattern: 'module.exports = { $$$ }', kind: 'value', multi: 'objectLiteral' },
+    { pattern: 'exports.$NAME = $$$', kind: 'value', nameVar: 'NAME' }
+  ],
+  functions: [
+    { pattern: 'function $NAME($$$) { $$$ }', nameVar: 'NAME' },
+    { pattern: 'async function $NAME($$$) { $$$ }', nameVar: 'NAME' },
+    { pattern: 'function* $NAME($$$) { $$$ }', nameVar: 'NAME' },
+    { pattern: 'async function* $NAME($$$) { $$$ }', nameVar: 'NAME' },
+    { pattern: 'const $NAME = ($$$) => $$$', nameVar: 'NAME' },
+    { pattern: 'const $NAME = async ($$$) => $$$', nameVar: 'NAME' },
+    { pattern: 'const $NAME = function ($$$) { $$$ }', nameVar: 'NAME' },
+    { pattern: 'const $NAME = async function ($$$) { $$$ }', nameVar: 'NAME' },
+    { pattern: 'let $NAME = ($$$) => $$$', nameVar: 'NAME' },
+    { pattern: 'var $NAME = ($$$) => $$$', nameVar: 'NAME' }
+  ],
+  classes: [
+    { pattern: 'class $NAME { $$$ }', nameVar: 'NAME' },
+    { pattern: 'const $NAME = class { $$$ }', nameVar: 'NAME' },
+    { pattern: 'const $NAME = class $CLASS { $$$ }', nameVar: 'NAME' }
+  ],
+  types: [],
+  constants: [],
+  imports: [
+    { pattern: 'import $NAME from $SOURCE', sourceVar: 'SOURCE', kind: 'default' },
+    { pattern: 'import * as $NAME from $SOURCE', sourceVar: 'SOURCE', kind: 'namespace' },
+    { pattern: 'import { $$$ } from $SOURCE', sourceVar: 'SOURCE', kind: 'named' },
+    { pattern: 'import $SOURCE', sourceVar: 'SOURCE', kind: 'side-effect' },
+    { pattern: 'const $NAME = require($SOURCE)', sourceVar: 'SOURCE', kind: 'require' },
+    { pattern: 'const { $$$ } = require($SOURCE)', sourceVar: 'SOURCE', kind: 'require' },
+    { pattern: 'require($SOURCE)', sourceVar: 'SOURCE', kind: 'require' }
+  ]
+};

package/plugins/audit-project/lib/repo-map/queries/python.js

@@ -0,0 +1,24 @@
+/**
+ * Python query patterns for ast-grep
+ */
+
+'use strict';
+
+module.exports = {
+  exports: [],
+  functions: [
+    { pattern: 'def $NAME($$$): $$$', nameVar: 'NAME' },
+    { pattern: 'async def $NAME($$$): $$$', nameVar: 'NAME' }
+  ],
+  classes: [
+    { pattern: 'class $NAME($$$): $$$', nameVar: 'NAME' },
+    { pattern: 'class $NAME: $$$', nameVar: 'NAME' }
+  ],
+  types: [],
+  constants: [],
+  imports: [
+    { pattern: 'import $SOURCE', sourceVar: 'SOURCE', kind: 'import', multiSource: true },
+    { pattern: 'from $SOURCE import $NAME', sourceVar: 'SOURCE', kind: 'from' },
+    { pattern: 'from $SOURCE import ($$$)', sourceVar: 'SOURCE', kind: 'from' }
+  ]
+};

package/plugins/audit-project/lib/repo-map/queries/rust.js

@@ -0,0 +1,73 @@
+/**
+ * Rust query patterns for ast-grep
+ */
+
+'use strict';
+
+module.exports = {
+  exports: [
+    { pattern: 'pub fn $NAME($$$) { $$$ }', kind: 'function', nameVar: 'NAME' },
+    { pattern: 'pub(crate) fn $NAME($$$) { $$$ }', kind: 'function', nameVar: 'NAME' },
+    { pattern: 'pub(super) fn $NAME($$$) { $$$ }', kind: 'function', nameVar: 'NAME' },
+    { pattern: 'pub(in $PATH) fn $NAME($$$) { $$$ }', kind: 'function', nameVar: 'NAME' },
+    { pattern: 'pub struct $NAME { $$$ }', kind: 'type', nameVar: 'NAME' },
+    { pattern: 'pub(crate) struct $NAME { $$$ }', kind: 'type', nameVar: 'NAME' },
+    { pattern: 'pub(super) struct $NAME { $$$ }', kind: 'type', nameVar: 'NAME' },
+    { pattern: 'pub(in $PATH) struct $NAME { $$$ }', kind: 'type', nameVar: 'NAME' },
+    { pattern: 'pub enum $NAME { $$$ }', kind: 'type', nameVar: 'NAME' },
+    { pattern: 'pub(crate) enum $NAME { $$$ }', kind: 'type', nameVar: 'NAME' },
+    { pattern: 'pub(super) enum $NAME { $$$ }', kind: 'type', nameVar: 'NAME' },
+    { pattern: 'pub(in $PATH) enum $NAME { $$$ }', kind: 'type', nameVar: 'NAME' },
+    { pattern: 'pub trait $NAME { $$$ }', kind: 'type', nameVar: 'NAME' },
+    { pattern: 'pub(crate) trait $NAME { $$$ }', kind: 'type', nameVar: 'NAME' },
+    { pattern: 'pub(super) trait $NAME { $$$ }', kind: 'type', nameVar: 'NAME' },
+    { pattern: 'pub(in $PATH) trait $NAME { $$$ }', kind: 'type', nameVar: 'NAME' },
+    { pattern: 'pub type $NAME = $$$', kind: 'type', nameVar: 'NAME' },
+    { pattern: 'pub(crate) type $NAME = $$$', kind: 'type', nameVar: 'NAME' },
+    { pattern: 'pub(super) type $NAME = $$$', kind: 'type', nameVar: 'NAME' },
+    { pattern: 'pub(in $PATH) type $NAME = $$$', kind: 'type', nameVar: 'NAME' },
+    { pattern: 'pub const $NAME: $TYPE = $$$', kind: 'constant', nameVar: 'NAME' },
+    { pattern: 'pub(crate) const $NAME: $TYPE = $$$', kind: 'constant', nameVar: 'NAME' },
+    { pattern: 'pub(super) const $NAME: $TYPE = $$$', kind: 'constant', nameVar: 'NAME' },
+    { pattern: 'pub(in $PATH) const $NAME: $TYPE = $$$', kind: 'constant', nameVar: 'NAME' },
+    { pattern: 'pub static $NAME: $TYPE = $$$', kind: 'constant', nameVar: 'NAME' },
+    { pattern: 'pub(crate) static $NAME: $TYPE = $$$', kind: 'constant', nameVar: 'NAME' },
+    { pattern: 'pub(super) static $NAME: $TYPE = $$$', kind: 'constant', nameVar: 'NAME' },
+    { pattern: 'pub(in $PATH) static $NAME: $TYPE = $$$', kind: 'constant', nameVar: 'NAME' },
+    { pattern: 'pub mod $NAME { $$$ }', kind: 'module', nameVar: 'NAME' },
+    { pattern: 'pub(crate) mod $NAME { $$$ }', kind: 'module', nameVar: 'NAME' },
+    { pattern: 'pub(super) mod $NAME { $$$ }', kind: 'module', nameVar: 'NAME' },
+    { pattern: 'pub(in $PATH) mod $NAME { $$$ }', kind: 'module', nameVar: 'NAME' },
+    { pattern: 'pub mod $NAME;', kind: 'module', nameVar: 'NAME' }
+  ],
+  functions: [
+    { pattern: 'fn $NAME($$$) { $$$ }', nameVar: 'NAME' },
+    { pattern: 'async fn $NAME($$$) { $$$ }', nameVar: 'NAME' },
+    { pattern: 'pub fn $NAME($$$) { $$$ }', nameVar: 'NAME' },
+    { pattern: 'pub(crate) fn $NAME($$$) { $$$ }', nameVar: 'NAME' },
+    { pattern: 'pub(super) fn $NAME($$$) { $$$ }', nameVar: 'NAME' },
+    { pattern: 'pub(in $PATH) fn $NAME($$$) { $$$ }', nameVar: 'NAME' },
+    { pattern: 'pub async fn $NAME($$$) { $$$ }', nameVar: 'NAME' },
+    { pattern: 'pub(crate) async fn $NAME($$$) { $$$ }', nameVar: 'NAME' }
+  ],
+  classes: [],
+  types: [
+    { pattern: 'struct $NAME { $$$ }', nameVar: 'NAME' },
+    { pattern: 'enum $NAME { $$$ }', nameVar: 'NAME' },
+    { pattern: 'trait $NAME { $$$ }', nameVar: 'NAME' },
+    { pattern: 'type $NAME = $$$', nameVar: 'NAME' },
+    { pattern: 'pub struct $NAME { $$$ }', nameVar: 'NAME' },
+    { pattern: 'pub enum $NAME { $$$ }', nameVar: 'NAME' },
+    { pattern: 'pub trait $NAME { $$$ }', nameVar: 'NAME' },
+    { pattern: 'pub type $NAME = $$$', nameVar: 'NAME' }
+  ],
+  constants: [
+    { pattern: 'const $NAME: $TYPE = $$$', nameVar: 'NAME' },
+    { pattern: 'static $NAME: $TYPE = $$$', nameVar: 'NAME' }
+  ],
+  imports: [
+    { pattern: 'use $SOURCE;', sourceVar: 'SOURCE', kind: 'use' },
+    { pattern: 'use $SOURCE::{ $$$ };', sourceVar: 'SOURCE', kind: 'use' },
+    { pattern: 'use $SOURCE::*;', sourceVar: 'SOURCE', kind: 'use' }
+  ]
+};

package/plugins/audit-project/lib/repo-map/queries/typescript.js

@@ -0,0 +1,38 @@
+/**
+ * TypeScript query patterns for ast-grep
+ */
+
+'use strict';
+
+const javascript = require('./javascript');
+
+module.exports = {
+  exports: [
+    ...javascript.exports,
+    { pattern: 'export interface $NAME { $$$ }', kind: 'type', nameVar: 'NAME' },
+    { pattern: 'export type $NAME = $$$', kind: 'type', nameVar: 'NAME' },
+    { pattern: 'export enum $NAME { $$$ }', kind: 'type', nameVar: 'NAME' },
+    { pattern: 'export namespace $NAME { $$$ }', kind: 'type', nameVar: 'NAME' },
+    { pattern: 'export const enum $NAME { $$$ }', kind: 'type', nameVar: 'NAME' },
+    { pattern: 'export = $NAME', kind: 'value', nameVar: 'NAME' },
+    { pattern: 'export as namespace $NAME', kind: 'namespace', nameVar: 'NAME' }
+  ],
+  functions: javascript.functions,
+  classes: [
+    ...javascript.classes,
+    { pattern: 'abstract class $NAME { $$$ }', nameVar: 'NAME' }
+  ],
+  types: [
+    { pattern: 'interface $NAME { $$$ }', nameVar: 'NAME' },
+    { pattern: 'type $NAME = $$$', nameVar: 'NAME' },
+    { pattern: 'enum $NAME { $$$ }', nameVar: 'NAME' },
+    { pattern: 'namespace $NAME { $$$ }', nameVar: 'NAME' },
+    { pattern: 'const enum $NAME { $$$ }', nameVar: 'NAME' }
+  ],
+  constants: javascript.constants,
+  imports: [
+    ...javascript.imports,
+    { pattern: 'import type { $$$ } from $SOURCE', sourceVar: 'SOURCE', kind: 'type' },
+    { pattern: 'import type $NAME from $SOURCE', sourceVar: 'SOURCE', kind: 'type' }
+  ]
+};