agentsys 5.1.0 → 5.2.0

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

@@ -1,212 +0,0 @@
-/**
- * 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

@@ -1,27 +0,0 @@
-/**
- * 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

@@ -1,100 +0,0 @@
-/**
- * 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

@@ -1,38 +0,0 @@
-/**
- * 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

@@ -1,55 +0,0 @@
-/**
- * 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

@@ -1,24 +0,0 @@
-/**
- * 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

@@ -1,73 +0,0 @@
-/**
- * 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

@@ -1,38 +0,0 @@
-/**
- * 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' }
-  ]
-};