@trustnext/ztam-analyzer 1.0.0

package/detectors/session/express-session.js

@@ -0,0 +1,37 @@
+'use strict';
+
+/**
+ * detectors/session/express-session.js
+ * Detects express-session usage and its backing store.
+ */
+
+const STORES = [
+  { name: 'Redis',      depSignals: ['connect-redis', 'ioredis'],              codeSignals: [/RedisStore/, /connect-redis/] },
+  { name: 'PostgreSQL', depSignals: ['connect-pg-simple'],                     codeSignals: [/PgSession/, /connect-pg-simple/] },
+  { name: 'MongoDB',    depSignals: ['connect-mongo', 'connect-mongodb-session'], codeSignals: [/MongoStore/, /connect-mongo/] },
+  { name: 'MySQL',      depSignals: ['express-mysql-session'],                 codeSignals: [/MySQLStore/, /express-mysql-session/] },
+];
+
+module.exports = {
+  name: 'express-session',
+  category: 'session',
+  depSignals: ['express-session'],
+  codeSignals: [/require\(['"]express-session['"]\)/, /app\.use\(session\(/],
+
+  scan(packageJson, files, allDeps, allCode) {
+    // Detect store
+    let store = 'In-memory (default)';
+    for (const s of STORES) {
+      if (s.depSignals.some(d => allDeps.has(d)) || s.codeSignals.some(re => re.test(allCode))) {
+        store = s.name;
+        break;
+      }
+    }
+    // Detect secure cookie
+    let secureCookie = null;
+    const secureMatch = allCode.match(/cookie\s*:\s*\{[^}]*secure\s*:\s*(true|false)/);
+    if (secureMatch) secureCookie = secureMatch[1] === 'true';
+
+    return { approach: 'express-session', store, cookieBased: true, secureCookie };
+  },
+};

package/detectors/session/jwt-stateless.js

@@ -0,0 +1,10 @@
+'use strict';
+module.exports = {
+  name: 'JWT stateless',
+  category: 'session',
+  depSignals: ['jsonwebtoken'],
+  codeSignals: [/jwt\.verify\(/, /jwt\.sign\(/],
+  scan() {
+    return { approach: 'JWT stateless', store: 'N/A (stateless)', cookieBased: false, secureCookie: null };
+  },
+};

package/index.js

@@ -0,0 +1,41 @@
+'use strict';
+
+/**
+ * index.js (v2) — Public programmatic API for @trustnext/ztam-analyzer
+ *
+ * READ-ONLY. Never modifies the client project.
+ */
+
+const path = require('path');
+const { scanProject }    = require('./lib/file-scanner');
+const { runAll }         = require('./detectors/index');
+const { generateReport } = require('./lib/report-generator');
+
+/**
+ * Analyzes a Node.js project and returns an integration report.
+ *
+ * @param {string} projectPath  Absolute or relative path to the client project root.
+ * @returns {{
+ *   terminal: string,
+ *   markdown: string,
+ *   json: string,
+ *   conflicts: Array,
+ *   strategy: Object,
+ *   complexity: string
+ * }}
+ */
+function analyze(projectPath) {
+  const absolutePath = path.resolve(projectPath);
+
+  // 1. Scan — read all files once into memory
+  const { files, packageJson } = scanProject(absolutePath);
+
+  // 2. Detect — run registry against FileMap
+  const detectionResult = runAll(packageJson, files);
+  detectionResult.projectPath = absolutePath;
+
+  // 3. Report — assemble and format
+  return generateReport(detectionResult);
+}
+
+module.exports = { analyze };

package/lib/file-scanner.js

@@ -0,0 +1,74 @@
+'use strict';
+
+/**
+ * file-scanner.js
+ *
+ * Walks a project directory recursively and returns a FileMap:
+ *   { 'relative/path/to/file.js': '<file contents>' }
+ *
+ * READ-ONLY. Never writes anything.
+ */
+
+const fs   = require('fs');
+const path = require('path');
+
+const SKIP_DIRS = new Set([
+  'node_modules', '.git', 'dist', 'build', '.next',
+  'coverage', '.cache', 'out', '.turbo', '.vercel',
+  'test', 'tests', 'spec', '__tests__', '__mocks__'
+]);
+
+const ALLOWED_EXTENSIONS = new Set([
+  '.js', '.ts', '.mjs', '.cjs', '.jsx', '.tsx',
+]);
+
+/**
+ * @param {string} projectRoot  Absolute path to the client project root.
+ * @returns {{ files: Object.<string,string>, packageJson: Object|null }}
+ */
+function scanProject(projectRoot) {
+  const files = {};
+  let packageJson = null;
+
+  // Read package.json at the root if it exists
+  const pkgPath = path.join(projectRoot, 'package.json');
+  if (fs.existsSync(pkgPath)) {
+    try {
+      packageJson = JSON.parse(fs.readFileSync(pkgPath, 'utf8'));
+    } catch (_) {
+      packageJson = null;
+    }
+  }
+
+  _walk(projectRoot, projectRoot, files);
+
+  return { files, packageJson };
+}
+
+function _walk(root, dir, files) {
+  let entries;
+  try {
+    entries = fs.readdirSync(dir, { withFileTypes: true });
+  } catch (_) {
+    return; // permission error or unreadable dir — skip silently
+  }
+
+  for (const entry of entries) {
+    if (entry.isDirectory()) {
+      if (SKIP_DIRS.has(entry.name)) continue;
+      _walk(root, path.join(dir, entry.name), files);
+    } else if (entry.isFile()) {
+      const ext = path.extname(entry.name).toLowerCase();
+      if (!ALLOWED_EXTENSIONS.has(ext)) continue;
+      const fullPath = path.join(dir, entry.name);
+      const relPath  = path.relative(root, fullPath);
+      try {
+        files[relPath] = fs.readFileSync(fullPath, 'utf8');
+      } catch (_) {
+        // unreadable file — skip silently
+      }
+    }
+  }
+}
+
+module.exports = { scanProject };