@numa-tech/numa 1.13.2 → 1.13.3

package/skills/numa-create-application/scripts/inspect-project.mjs

@@ -0,0 +1,243 @@
+#!/usr/bin/env node
+
+import { execFileSync } from 'node:child_process';
+import { existsSync, readFileSync, readdirSync, statSync } from 'node:fs';
+import { basename, join, resolve } from 'node:path';
+
+const root = resolve(process.argv[2] ?? process.cwd());
+if (!existsSync(root) || !statSync(root).isDirectory()) {
+  process.stderr.write('Project directory does not exist or is not a directory.\n');
+  process.exit(2);
+}
+
+const excludedDirectories = new Set([
+  '.git', '.idea', '.next', '.nuxt', '.output', '.turbo', '.venv',
+  '.superpowers', '.worktrees', 'coverage', 'dist', 'node_modules', 'out',
+  'target', 'test-results'
+]);
+const sensitiveNames = /^(?:\.env(?:\..*)?|.*(?:secret|credential|private[-_.]?key|token).*)$/iu;
+const maximumFiles = 5_000;
+const maximumDepth = 7;
+const files = [];
+
+function walk(directory, depth = 0) {
+  if (depth > maximumDepth || files.length >= maximumFiles) return;
+  let entries = [];
+  try {
+    entries = readdirSync(directory, { withFileTypes: true });
+  } catch {
+    return;
+  }
+  for (const entry of entries) {
+    if (files.length >= maximumFiles) break;
+    if (entry.isDirectory()) {
+      if (!excludedDirectories.has(entry.name) && !sensitiveNames.test(entry.name)) {
+        walk(join(directory, entry.name), depth + 1);
+      }
+      continue;
+    }
+    if (entry.isFile() && !sensitiveNames.test(entry.name)) files.push(join(directory, entry.name));
+  }
+}
+
+walk(root);
+const relativeFiles = files.map((file) => file.slice(root.length + 1));
+const fileSet = new Set(relativeFiles);
+
+function text(relativePath, maximumBytes = 1_000_000) {
+  if (!fileSet.has(relativePath)) return null;
+  try {
+    const value = readFileSync(join(root, relativePath));
+    return value.byteLength <= maximumBytes ? value.toString('utf8') : null;
+  } catch {
+    return null;
+  }
+}
+
+function json(relativePath) {
+  const value = text(relativePath);
+  if (!value) return null;
+  try {
+    return JSON.parse(value);
+  } catch {
+    return null;
+  }
+}
+
+function git(args) {
+  try {
+    return execFileSync('git', args, {
+      cwd: root,
+      encoding: 'utf8',
+      stdio: ['ignore', 'pipe', 'ignore'],
+      maxBuffer: 2_000_000
+    }).trim();
+  } catch {
+    return null;
+  }
+}
+
+function sanitizeRemote(value) {
+  if (!value) return null;
+  try {
+    const parsed = new URL(value);
+    parsed.username = '';
+    parsed.password = '';
+    parsed.search = '';
+    parsed.hash = '';
+    return parsed.toString();
+  } catch {
+    return value
+      .replace(/^[^@\s]+@([^:]+):/u, '$1:')
+      .replace(/([?&](?:access_?token|token|password|secret)=)[^&#\s]+/giu, '$1[REDACTED]');
+  }
+}
+
+function slug(value) {
+  return String(value ?? '')
+    .trim()
+    .replace(/^@[^/]+\//u, '')
+    .replace(/\.git$/u, '')
+    .split(/[/:]/u)
+    .at(-1)
+    ?.toLowerCase()
+    .replace(/[^a-z0-9]+/gu, '-')
+    .replace(/^-+|-+$/gu, '') || null;
+}
+
+const packageFiles = relativeFiles.filter((file) => /(^|\/)package\.json$/u.test(file));
+const manifests = packageFiles.flatMap((file) => {
+  const value = json(file);
+  return value && typeof value === 'object' ? [{ file, value }] : [];
+});
+const rootPackage = manifests.find((entry) => entry.file === 'package.json')?.value ?? null;
+const dependencies = new Set();
+for (const { value } of manifests) {
+  for (const section of ['dependencies', 'devDependencies', 'peerDependencies']) {
+    for (const name of Object.keys(value[section] ?? {})) dependencies.add(name);
+  }
+}
+
+const jenkins = text('Jenkinsfile') ?? '';
+const dockerfile = text('Dockerfile') ?? '';
+const jenkinsVariables = {};
+for (const key of ['APP_NAME', 'APP_HOME', 'BUILD_FLOW', 'TRIGGER_BUILD', 'NODE_VERSION', 'JDK_VERSION', 'SONAR_SCAN']) {
+  const match = jenkins.match(new RegExp(`\\b${key}\\s*=\\s*["']([^"']+)["']`, 'u'));
+  if (match) jenkinsVariables[key] = match[1];
+}
+
+const remoteNames = (git(['remote']) ?? '').split(/\r?\n/u).filter(Boolean);
+const remotes = remoteNames.map((name) => ({
+  name,
+  url: sanitizeRemote(git(['remote', 'get-url', name]))
+}));
+const primaryRemote = remotes.find((item) => item.name === 'origin') ?? remotes[0] ?? null;
+const statusLines = (git(['status', '--porcelain', '--untracked-files=all']) ?? '')
+  .split(/\r?\n/u).filter(Boolean);
+const branch = git(['branch', '--show-current']);
+const head = git(['rev-parse', 'HEAD']);
+const upstream = git(['rev-parse', '--abbrev-ref', '--symbolic-full-name', '@{upstream}']);
+const isGitRepository = git(['rev-parse', '--is-inside-work-tree']) === 'true';
+const trackedPathCount = (git(['ls-files', '-z']) ?? '').split('\0').filter(Boolean).length;
+const executableTrackedPathCount = (git(['ls-files', '-s', '-z']) ?? '')
+  .split('\0')
+  .filter((entry) => entry.startsWith('100755 '))
+  .length;
+const sourceState = !isGitRepository ? 'UNVERSIONED_DIRECTORY'
+  : statusLines.length > 0 ? 'DIRTY_WORKTREE'
+    : remoteNames.length === 0 && head ? 'LOCAL_HISTORY_WITHOUT_REMOTE'
+      : remoteNames.length > 0 && !upstream ? 'REMOTE_WITHOUT_UPSTREAM'
+        : 'REMOTE_TRACKED';
+
+const technologies = [];
+function technology(code, evidence) {
+  technologies.push({ code, evidence });
+}
+if (fileSet.has('pom.xml')) technology('java-maven', 'pom.xml');
+if (fileSet.has('settings.gradle.kts') || fileSet.has('build.gradle.kts')) technology('java-gradle', 'Gradle Kotlin DSL');
+if (fileSet.has('go.mod')) technology('go', 'go.mod');
+if (fileSet.has('pyproject.toml')) technology('python', 'pyproject.toml');
+if (dependencies.has('@nestjs/core')) technology('nestjs', '@nestjs/core dependency');
+if (dependencies.has('next')) technology('nextjs', 'next dependency');
+if (dependencies.has('nuxt')) technology('nuxt', 'nuxt dependency');
+if (dependencies.has('fastify')) technology('fastify', 'fastify dependency');
+if (dependencies.has('express')) technology('express', 'express dependency');
+if (dependencies.has('vite')) technology('vite', 'vite dependency');
+if (rootPackage && technologies.length === 0) technology('node', 'package.json');
+
+const databaseSignals = [];
+const databasePackages = new Map([
+  ['pg', 'POSTGRESQL'], ['postgres', 'POSTGRESQL'], ['drizzle-orm', 'SQL'],
+  ['@prisma/client', 'SQL'], ['mysql2', 'MYSQL'], ['mariadb', 'MYSQL'],
+  ['mongodb', 'MONGODB'], ['mongoose', 'MONGODB'], ['better-sqlite3', 'SQLITE'], ['sqlite3', 'SQLITE']
+]);
+for (const [name, engine] of databasePackages) {
+  if (dependencies.has(name)) databaseSignals.push({ engine, evidence: `dependency:${name}` });
+}
+for (const file of relativeFiles) {
+  if (/\/(?:drizzle|prisma|migrations?)\//u.test(`/${file}`)) {
+    databaseSignals.push({ engine: 'UNKNOWN_SQL', evidence: `path:${file}` });
+    if (databaseSignals.length >= 20) break;
+  }
+}
+
+const packageManager = fileSet.has('pnpm-lock.yaml') ? 'pnpm'
+  : fileSet.has('yarn.lock') ? 'yarn'
+    : fileSet.has('package-lock.json') ? 'npm'
+      : fileSet.has('bun.lockb') || fileSet.has('bun.lock') ? 'bun' : null;
+const remoteSlug = slug(primaryRemote?.url);
+const packageSlug = slug(rootPackage?.name);
+const appCodeCandidate = slug(jenkinsVariables.APP_NAME) ?? remoteSlug ?? packageSlug ?? slug(basename(root));
+
+const result = {
+  schemaVersion: 1,
+  scan: {
+    directoryName: basename(root),
+    filesConsidered: relativeFiles.length,
+    truncated: files.length >= maximumFiles,
+    maximumDepth,
+    sensitiveFilesRead: false
+  },
+  application: {
+    codeCandidate: appCodeCandidate,
+    evidence: jenkinsVariables.APP_NAME ? 'Jenkinsfile:APP_NAME'
+      : remoteSlug ? 'git:primary-remote' : rootPackage?.name ? 'package.json:name' : 'directory-name',
+    packageName: rootPackage?.name ?? null
+  },
+  git: {
+    repository: isGitRepository,
+    sourceState,
+    branch: branch || null,
+    head: head || null,
+    upstream: upstream || null,
+    dirty: statusLines.length > 0,
+    changedPathCount: statusLines.length,
+    trackedPathCount,
+    executableTrackedPathCount,
+    remotes
+  },
+  build: {
+    packageManager,
+    packageFiles,
+    technologies,
+    jenkinsfile: fileSet.has('Jenkinsfile'),
+    jenkinsVariables,
+    buildEntry: /\bbuildEntry\(\)/u.test(jenkins),
+    dockerfile: fileSet.has('Dockerfile'),
+    dockerExposedPorts: [...dockerfile.matchAll(/^EXPOSE\s+([^\r\n#]+)/gmu)].map((match) => match[1].trim()),
+    hasCompose: fileSet.has('compose.yaml') || fileSet.has('docker-compose.yml')
+  },
+  database: {
+    signals: databaseSignals,
+    recommendation: databaseSignals.length === 0 ? 'NONE'
+      : databaseSignals.some((item) => item.engine === 'POSTGRESQL') ? 'POSTGRESQL'
+        : databaseSignals.every((item) => item.engine === databaseSignals[0]?.engine) ? databaseSignals[0]?.engine : 'REVIEW'
+  },
+  deployment: {
+    hasHelm: relativeFiles.some((file) => /(^|\/)Chart\.ya?ml$/u.test(file)),
+    hasKubernetesManifests: relativeFiles.some((file) => /(^|\/)(?:k8s|kubernetes|helm)\//u.test(file)),
+    hasCloudflareWorker: relativeFiles.some((file) => /(^|\/)wrangler(?:\.[^.]+)?\.(?:toml|jsonc?)$/u.test(file))
+  }
+};
+
+process.stdout.write(`${JSON.stringify(result, null, 2)}\n`);