dinorex 1.0.0

package/src/scanner.js

@@ -0,0 +1,119 @@
+import { glob } from "glob";
+import { readFileSync } from "fs";
+import path from "path";
+
+const ROUTE_PATTERNS = [
+  "**/routes/**/*.{js,ts,tsx}",
+  "**/route/**/*.{js,ts,tsx}",
+  "**/router/**/*.{js,ts,tsx}",
+  "**/*route*.{js,ts,tsx}",
+  "**/*router*.{js,ts,tsx}",
+  "**/*Route*.{js,ts,tsx}",
+  "**/*Router*.{js,ts,tsx}",
+];
+
+const CONTROLLER_PATTERNS = [
+  "**/controllers/**/*.{js,ts,tsx}",
+  "**/controller/**/*.{js,ts,tsx}",
+  "**/*controller*.{js,ts,tsx}",
+  "**/*Controller*.{js,ts,tsx}",
+];
+
+const SERVICE_PATTERNS = [
+  "**/services/**/*.{js,ts,tsx}",
+  "**/service/**/*.{js,ts,tsx}",
+  "**/*service*.{js,ts,tsx}",
+  "**/*Service*.{js,ts,tsx}",
+];
+
+const MODEL_PATTERNS = [
+  "**/models/**/*.{js,ts,tsx}",
+  "**/model/**/*.{js,ts,tsx}",
+  "**/schemas/**/*.{js,ts,tsx}",
+  "**/schema/**/*.{js,ts,tsx}",
+  "**/entities/**/*.{js,ts,tsx}",
+  "**/dto/**/*.{js,ts,tsx}",
+  "**/dtos/**/*.{js,ts,tsx}",
+  "**/*model*.{js,ts,tsx}",
+  "**/*Model*.{js,ts,tsx}",
+  "**/*schema*.{js,ts,tsx}",
+  "**/*Schema*.{js,ts,tsx}",
+  "**/*entity*.{js,ts,tsx}",
+  "**/*Entity*.{js,ts,tsx}",
+  "**/*.dto.{ts,tsx}",
+];
+
+const IGNORE_DIRS = [
+  "**/node_modules/**",
+  "**/.git/**",
+  "**/dist/**",
+  "**/build/**",
+  "**/.next/**",
+  "**/coverage/**",
+  "**/*.test.*",
+  "**/*.spec.*",
+  "**/__tests__/**",
+];
+
+async function findFiles(patterns, cwd) {
+  const results = new Set();
+  for (const pattern of patterns) {
+    const files = await glob(pattern, { cwd, ignore: IGNORE_DIRS, absolute: true });
+    files.forEach((f) => results.add(f));
+  }
+  return [...results];
+}
+
+function readFile(filePath) {
+  try {
+    return readFileSync(filePath, "utf-8");
+  } catch {
+    return null;
+  }
+}
+
+function truncate(content, maxChars = 8000) {
+  if (content.length <= maxChars) return content;
+  return content.slice(0, maxChars) + "\n\n... [truncated for length]";
+}
+
+export async function scanProject(targetDir) {
+  const cwd = path.resolve(targetDir);
+
+  console.log(`\n🦕 Dinorex scanning: ${cwd}\n`);
+
+  const [routeFiles, controllerFiles, serviceFiles, modelFiles] = await Promise.all([
+    findFiles(ROUTE_PATTERNS, cwd),
+    findFiles(CONTROLLER_PATTERNS, cwd),
+    findFiles(SERVICE_PATTERNS, cwd),
+    findFiles(MODEL_PATTERNS, cwd),
+  ]);
+
+  const summary = {
+    routes: routeFiles.length,
+    controllers: controllerFiles.length,
+    services: serviceFiles.length,
+    models: modelFiles.length,
+  };
+
+  const collected = {
+    routes: routeFiles.map((f) => ({
+      path: path.relative(cwd, f),
+      content: truncate(readFile(f) || ""),
+    })),
+    controllers: controllerFiles.map((f) => ({
+      path: path.relative(cwd, f),
+      content: truncate(readFile(f) || ""),
+    })),
+    services: serviceFiles.map((f) => ({
+      path: path.relative(cwd, f),
+      content: truncate(readFile(f) || ""),
+    })),
+    models: modelFiles.map((f) => ({
+      path: path.relative(cwd, f),
+      content: truncate(readFile(f) || ""),
+    })),
+  };
+
+  return { cwd, summary, collected };
+}

package/src/server.js

@@ -0,0 +1,136 @@
+import express from "express";
+import cors from "cors";
+import path from "path";
+import { fileURLToPath } from "url";
+import { scanProject } from "./scanner.js";
+import { analyzeWithAI, analyzeIncremental } from "./agent.js";
+import { generatePostmanCollection } from "./generators/postman.js";
+import { generateSwaggerSpec } from "./generators/swagger.js";
+import { loadStore, saveStore, diffScan } from "./store.js";
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+
+export async function startServer(targetDir, options = {}) {
+  const { port = 4321, _cachedSpec = null } = options;
+
+  const app = express();
+  app.use(cors());
+  app.use(express.json());
+  app.use(express.static(path.join(__dirname, "public")));
+
+  let specCache = _cachedSpec;
+  let isAnalyzing = false;
+  let analysisStatus = _cachedSpec ? { state: "ready" } : { state: "pending", message: "Starting analysis..." };
+
+  async function runAnalysis(forceRescan = false) {
+    if (isAnalyzing) return;
+    isAnalyzing = true;
+
+    try {
+      const { collected, summary } = await scanProject(targetDir);
+      const allFiles = [
+        ...collected.routes,
+        ...collected.controllers,
+        ...collected.services,
+        ...collected.models,
+      ];
+
+      const stored = loadStore(targetDir);
+
+      if (!forceRescan && stored && stored.spec && stored.hashes) {
+        // Incremental mode
+        analysisStatus = { state: "analyzing", message: "Checking for new/changed endpoints..." };
+        const diff = diffScan(stored.hashes, allFiles);
+
+        const { spec, changed } = await analyzeIncremental(stored.spec, diff);
+        specCache = spec;
+
+        if (changed) {
+          saveStore(targetDir, { spec, hashes: diff.newHashes, lastScan: new Date().toISOString() });
+          analysisStatus = { state: "ready", message: "Spec updated with new endpoints." };
+        } else {
+          analysisStatus = { state: "ready", message: "No changes detected." };
+        }
+      } else {
+        // Full scan
+        analysisStatus = { state: "analyzing", message: "Running full AI analysis..." };
+        const projectName = path.basename(targetDir);
+        specCache = await analyzeWithAI(collected, projectName);
+
+        const hashes = {};
+        for (const f of allFiles) {
+          const { createHash } = await import("crypto");
+          hashes[f.path] = { hash: createHash("md5").update(f.content).digest("hex") };
+        }
+        saveStore(targetDir, { spec: specCache, hashes, lastScan: new Date().toISOString() });
+        analysisStatus = { state: "ready", message: "Full analysis complete." };
+      }
+    } catch (err) {
+      analysisStatus = { state: "error", message: err.message };
+    } finally {
+      isAnalyzing = false;
+    }
+  }
+
+  // On startup: use cache if no cached spec passed in
+  if (!specCache) {
+    const stored = loadStore(targetDir);
+    if (stored?.spec) {
+      specCache = stored.spec;
+      analysisStatus = { state: "ready", message: "Loaded from cache." };
+      // Still run incremental check in background
+      runAnalysis(false);
+    } else {
+      runAnalysis(true);
+    }
+  } else {
+    analysisStatus = { state: "ready" };
+  }
+
+  // ── Routes ──────────────────────────────────────────────────────────────
+
+  app.get("/api/status", (req, res) => res.json(analysisStatus));
+
+  app.get("/api/spec", (req, res) => {
+    if (!specCache) return res.json({ _loading: true, status: analysisStatus });
+    res.json(specCache);
+  });
+
+  app.post("/api/rescan", async (req, res) => {
+    if (isAnalyzing) return res.json({ message: "Already scanning..." });
+    runAnalysis(false); // incremental
+    res.json({ message: "Rescan started" });
+  });
+
+  app.post("/api/rescan/full", async (req, res) => {
+    if (isAnalyzing) return res.json({ message: "Already scanning..." });
+    runAnalysis(true); // force full
+    res.json({ message: "Full rescan started" });
+  });
+
+  app.get("/api/export/postman", (req, res) => {
+    if (!specCache) return res.status(503).json({ error: "Still analyzing" });
+    const collection = generatePostmanCollection(specCache);
+    res.setHeader("Content-Type", "application/json");
+    res.setHeader("Content-Disposition", `attachment; filename="${specCache.projectName.replace(/\s+/g, "-")}-postman.json"`);
+    res.json(collection);
+  });
+
+  app.get("/api/export/swagger", (req, res) => {
+    if (!specCache) return res.status(503).json({ error: "Still analyzing" });
+    const yamlContent = generateSwaggerSpec(specCache);
+    res.setHeader("Content-Type", "application/x-yaml");
+    res.setHeader("Content-Disposition", `attachment; filename="${specCache.projectName.replace(/\s+/g, "-")}-openapi.yaml"`);
+    res.send(yamlContent);
+  });
+
+  app.get("*", (req, res) => {
+    res.sendFile(path.join(__dirname, "public", "index.html"));
+  });
+
+  return new Promise((resolve) => {
+    const server = app.listen(port, () => {
+      resolve({ server, port, url: `http://localhost:${port}` });
+    });
+  });
+}

package/src/store.js

@@ -0,0 +1,80 @@
+/**
+ * Persistent spec store — saves to .dinorex/spec.json in the user's project.
+ * Tracks which files have been seen so we can detect new/changed routes.
+ */
+import { readFileSync, writeFileSync, mkdirSync, existsSync } from "fs";
+import path from "path";
+import crypto from "crypto";
+
+function storePath(projectDir) {
+  return path.join(projectDir, ".dinorex");
+}
+
+function specFile(projectDir) {
+  return path.join(storePath(projectDir), "spec.json");
+}
+
+function hashContent(content) {
+  return crypto.createHash("md5").update(content).digest("hex");
+}
+
+export function loadStore(projectDir) {
+  const file = specFile(projectDir);
+  if (!existsSync(file)) return null;
+  try {
+    return JSON.parse(readFileSync(file, "utf-8"));
+  } catch {
+    return null;
+  }
+}
+
+export function saveStore(projectDir, data) {
+  const dir = storePath(projectDir);
+  mkdirSync(dir, { recursive: true });
+
+  // write a .gitignore inside .dinorex so spec isn't committed
+  const gi = path.join(dir, ".gitignore");
+  if (!existsSync(gi)) writeFileSync(gi, "*\n");
+
+  writeFileSync(specFile(projectDir), JSON.stringify(data, null, 2));
+}
+
+/**
+ * Compare new scan against stored file hashes.
+ * Returns:
+ *  - newFiles   : files that didn't exist before
+ *  - changedFiles: files whose content changed
+ *  - removedFiles: files that no longer exist
+ *  - unchanged  : everything else
+ */
+export function diffScan(storedHashes = {}, currentFiles) {
+  const currentHashes = {};
+  for (const f of currentFiles) {
+    currentHashes[f.path] = { hash: hashContent(f.content), content: f.content };
+  }
+
+  const newFiles = [];
+  const changedFiles = [];
+  const unchanged = [];
+
+  for (const f of currentFiles) {
+    const prev = storedHashes[f.path];
+    if (!prev) {
+      newFiles.push(f);
+    } else if (prev.hash !== currentHashes[f.path].hash) {
+      changedFiles.push(f);
+    } else {
+      unchanged.push(f);
+    }
+  }
+
+  const currentPaths = new Set(currentFiles.map(f => f.path));
+  const removedFiles = Object.keys(storedHashes).filter(p => !currentPaths.has(p));
+
+  const newHashes = {};
+  for (const f of currentFiles) {
+    newHashes[f.path] = { hash: currentHashes[f.path].hash };
+  }
+
+  return { newFiles, changedFiles, removedFiles, unchanged, newHashes };
+}