mdsmith 1.1.2 → 1.2.1

package/mdsmith.config.json

@@ -4,5 +4,6 @@
     ".git",
     ".vscode"
   ],
-  "depth": 1
+  "depth": null,
+  "emojis": true
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://json.schemastore.org/package.json",
   "name": "mdsmith",
-  "version": "1.1.2",
+  "version": "1.2.1",
   "description": "CLI para gerar READMEs e arquivos Markdown",
   "bin": {
     "mdsmith": "./bin/index.js"
@@ -10,5 +10,8 @@
   "license": "MIT",
   "engines": {
     "node": ">=18"
+  },
+  "dependencies": {
+    "prompts": "^2.4.2"
   }
 }

package/src/analysis/index.js

@@ -0,0 +1,149 @@
+
+
+const fs = require("fs")
+const path = require("path")
+const prompts = require('prompts');
+
+const detectors = require("../../src/detectors")
+
+function analisarProjeto(packageJson, projectRoot) {
+  const deps = {
+    ...packageJson.dependencies,
+    ...packageJson.devDependencies
+  }
+
+  const analysis = {
+    frontend: deps.react ? "React" :
+              deps.next ? "Next.js" :
+              null,
+
+    backend: deps.express ? "Express" :
+             deps.fastify ? "Fastify" :
+             null,
+
+    language: deps.typescript ? "TypeScript" : "JavaScript",
+
+    bundler: deps.vite ? "Vite" :
+             deps.webpack ? "Webpack" :
+             null,
+
+    styling: deps.tailwindcss ? "TailwindCSS" :
+             deps.sass ? "Sass" :
+             null,
+
+    database: deps.mongoose ? "MongoDB" :
+              deps.prisma ? "Prisma" :
+              deps.pg ? "PostgreSQL" :
+              null,
+
+    testing: deps.jest ? "Jest" :
+             deps.vitest ? "Vitest" :
+             null,
+
+    linting: deps.eslint ? "ESLint" : null,
+
+    formatting: deps.prettier ? "Prettier" : null,
+
+    node: detectors.detectarNodeVersion(projectRoot, packageJson)
+  }
+
+  if (analysis.frontend && analysis.backend) {
+    analysis.architecture = "Fullstack"
+  } else if (analysis.frontend) {
+    analysis.architecture = "Frontend"
+  } else if (analysis.backend) {
+    analysis.architecture = "Backend"
+  }
+
+  return analysis
+}
+
+function diagnosticarExecucao(commands) {
+  const warnings = []
+
+  if (!commands.dev && !commands.start) {
+    warnings.push("No development or start script found.")
+  }
+
+  if (commands.build && !commands.start) {
+    warnings.push("Build script found but no start script for production.")
+  }
+
+  return warnings
+}
+
+function healthChecks(packageJson, projectRoot, analysis) {
+  const checks = []
+
+  if (!analysis.testing) {
+    checks.push({
+      type: "warning",
+      message: "No test runner configured."
+    })
+  }
+
+  if (!analysis.linting) {
+    checks.push({
+      type: "info",
+      message: "No ESLint detected."
+    })
+  }
+
+  if (!analysis.formatting) {
+    checks.push({
+      type: "info",
+      message: "No Prettier detected."
+    })
+  }
+
+  if (!packageJson.engines?.node) {
+    checks.push({
+      type: "critical",
+      message: "Node version not defined in package.json engines."
+    })
+  }
+
+  if (!fs.existsSync(path.join(projectRoot, "Dockerfile"))) {
+    checks.push({
+      type: "info",
+      message: "No Dockerfile found."
+    })
+  }
+
+  return checks
+}
+
+function analisarScripts(scripts = {}, packageManager) {
+  const commands = {
+    install: packageManager === "npm"
+      ? "npm install"
+      : `${packageManager} install`
+  }
+
+  if (scripts.dev) {
+    commands.dev = `${packageManager} run dev`
+  }
+
+  if (scripts.build) {
+    commands.build = `${packageManager} run build`
+  }
+
+  if (scripts.start) {
+    commands.start = packageManager === "npm"
+      ? "npm start"
+      : `${packageManager} start`
+  }
+
+  if (scripts.preview) {
+    commands.preview = `${packageManager} run preview`
+  }
+
+  return commands
+}
+
+module.exports = {
+    analisarProjeto,
+    diagnosticarExecucao,
+    healthChecks,
+    analisarScripts
+}

package/src/config/index.js

@@ -0,0 +1,43 @@
+
+const fs = require("fs")
+const path = require("path")
+const prompts = require('prompts');
+
+const defaultConfig = {
+  ignore: ["node_modules", ".git", ".vscode"],
+  depth: Infinity,
+  emojis: true
+}
+
+
+function loadConfig(projectRoot) {
+  const configPath = path.join(projectRoot, "mdsmith.config.json")
+
+  if (!fs.existsSync(configPath)) {
+    return defaultConfig
+  }
+
+  try {
+    const fileContent = fs.readFileSync(configPath, "utf-8")
+    const userConfig = JSON.parse(fileContent)
+
+    return {
+        ...defaultConfig,
+        ...userConfig,
+        ignore: [
+            ...defaultConfig.ignore,
+            ...(userConfig.ignore || [])
+        ]
+    }
+
+
+  } catch (error) {
+    console.log("Failed to read mdsmith.config.json. Using default configuration.")
+    return defaultConfig
+  }
+}
+
+module.exports = {
+    defaultConfig,
+    loadConfig
+}

package/src/detectors/index.js

@@ -0,0 +1,203 @@
+const fs = require("fs")
+const path = require("path")
+
+const TECH_MAP = {
+  // Frameworks
+  express: "Express",
+  fastify: "Fastify",
+  koa: "Koa",
+  hapi: "Hapi",
+  "@nestjs/core": "NestJS",
+
+  // ORMs
+  prisma: "Prisma",
+  "@prisma/client": "Prisma",
+  sequelize: "Sequelize",
+  mongoose: "Mongoose",
+  typeorm: "TypeORM",
+  drizzle: "Drizzle ORM",
+
+  // Databases
+  pg: "PostgreSQL",
+  mysql: "MySQL",
+  mysql2: "MySQL",
+  sqlite3: "SQLite",
+  mongodb: "MongoDB",
+
+  // Auth
+  jsonwebtoken: "JWT",
+  passport: "Passport",
+
+  // AI
+  openai: "OpenAI",
+  langchain: "LangChain",
+
+  // Infra / Tools
+  docker: "Docker",
+  "swagger-ui-express": "Swagger",
+  puppeteer: "Puppeteer",
+  nodemailer: "Nodemailer"
+}
+
+function detectarTechStack(deps = {}) {
+  const stack = new Set()
+
+  for (const dep in deps) {
+    if (TECH_MAP[dep]) {
+      stack.add(TECH_MAP[dep])
+    }
+  }
+
+  return Array.from(stack).sort()
+}
+
+
+function detectarEnvVars(projectRoot) {
+  const envPath = path.join(projectRoot, ".env")
+
+  if (!fs.existsSync(envPath)) return []
+
+  const content = fs.readFileSync(envPath, "utf-8")
+
+  const vars = content
+    .split("\n")
+    .map(line => line.trim())
+    .filter(line =>
+      line &&
+      !line.startsWith("#") &&
+      line.includes("=")
+    )
+    .map(line => line.replace(/^export\s+/, ""))
+    .map(line => line.split("=")[0].trim())
+
+  return vars
+}
+
+function detectarPorta(scanData) {
+  const filesToScan = [...scanData.jsFiles, ...scanData.tsFiles]
+
+  for (const filePath of filesToScan) {
+    try {
+      const content = fs.readFileSync(filePath, "utf-8")
+
+      // 🔎 Regex robusta: pega .listen(...) mesmo com quebra de linha
+      const listenRegex = /\.listen\s*\(\s*([\s\S]*?)\)/g
+
+      let match
+
+      while ((match = listenRegex.exec(content)) !== null) {
+        const rawArgument = match[1].split(",")[0].trim()
+
+        // =============================
+        // ✅ 1️⃣ Número direto
+        // =============================
+        const directNumber = rawArgument.match(/^\d+$/)
+        if (directNumber) {
+          return directNumber[0]
+        }
+
+        // =============================
+        // ✅ 2️⃣ Fallback inline
+        // =============================
+        const inlineFallback = rawArgument.match(/\|\|\s*(\d+)/)
+        if (inlineFallback) {
+          return inlineFallback[1]
+        }
+
+        // =============================
+        // ✅ 3️⃣ process.env.PORT
+        // =============================
+        if (rawArgument.includes("process.env.PORT")) {
+          return "process.env.PORT"
+        }
+
+        // =============================
+        // ✅ 4️⃣ Resolver variável
+        // =============================
+        const variableName = rawArgument.replace(/[^a-zA-Z0-9_]/g, "")
+
+        if (!variableName) continue
+
+        const variableRegex = new RegExp(
+          `(const|let|var)\\s+${variableName}\\s*=\\s*([\\s\\S]*?);`
+        )
+
+        const variableMatch = content.match(variableRegex)
+
+        if (variableMatch) {
+          const variableValue = variableMatch[2]
+
+          const fallbackMatch = variableValue.match(/\|\|\s*(\d+)/)
+          if (fallbackMatch) {
+            return fallbackMatch[1]
+          }
+
+          const numberMatch = variableValue.match(/\d+/)
+          if (numberMatch) {
+            return numberMatch[0]
+          }
+        }
+      }
+
+    } catch (err) {
+      continue
+    }
+  }
+
+  return null
+}
+
+function detectarPackageManager(projectRoot) {
+  if (fs.existsSync(path.join(projectRoot, "pnpm-lock.yaml"))) {
+    return "pnpm"
+  }
+
+  if (fs.existsSync(path.join(projectRoot, "yarn.lock"))) {
+    return "yarn"
+  }
+
+  if (fs.existsSync(path.join(projectRoot, "package-lock.json"))) {
+    return "npm"
+  }
+
+  return "npm"
+}
+
+function detectarNodeVersion(projectRoot, packageJson) {
+  if (packageJson.engines && packageJson.engines.node) {
+    return packageJson.engines.node
+  }
+
+  const nvmrcPath = path.join(projectRoot, ".nvmrc")
+  if (fs.existsSync(nvmrcPath)) {
+    return fs.readFileSync(nvmrcPath, "utf-8").trim()
+  }
+
+  const nodeVersionPath = path.join(projectRoot, ".node-version")
+  if (fs.existsSync(nodeVersionPath)) {
+    return fs.readFileSync(nodeVersionPath, "utf-8").trim()
+  }
+
+  return process.version
+}
+
+function detectarPrisma(projectRoot, packageJson) {
+  const deps = {
+    ...packageJson.dependencies,
+    ...packageJson.devDependencies
+  }
+
+  const hasPrismaDep = deps.prisma || deps["@prisma/client"]
+  const hasPrismaFolder = fs.existsSync(path.join(projectRoot, "prisma"))
+
+  return hasPrismaDep && hasPrismaFolder
+}
+
+module.exports = {
+detectarEnvVars,
+detectarPorta,
+detectarTechStack,
+detectarPackageManager,
+detectarNodeVersion,
+detectarPrisma
+}

package/src/formatters/index.js

@@ -0,0 +1,53 @@
+
+function formatarAnalise(analysis) {
+  console.log(`
+Project Analysis
+────────────────────────
+  `)
+
+  const entries = Object.entries(analysis)
+
+  for (const [key, value] of entries) {
+    if (value) {
+      const label = key.charAt(0).toUpperCase() + key.slice(1)
+      console.log(`✓ ${label}: ${value}`)
+    }
+  }
+
+  console.log("")
+}
+
+function formatarExecucao(commands, warnings) {
+  console.log(`Project Execution Strategy
+────────────────────────`)
+
+  console.log(`Install:`)
+  console.log(`  ${commands.install}\n`)
+
+  if (commands.dev) {
+    console.log(`Development:`)
+    console.log(`  ${commands.dev}\n`)
+  }
+
+  if (commands.build && commands.start) {
+    console.log(`Production:`)
+    console.log(`  ${commands.build}`)
+    console.log(`  ${commands.start}\n`)
+  }
+
+  if (commands.preview) {
+    console.log(`Preview:`)
+    console.log(`  ${commands.preview}\n`)
+  }
+
+  if (warnings.length > 0) {
+    console.log(`Warnings:`)
+    warnings.forEach(w => console.log(`  ⚠ ${w}`))
+    console.log()
+  }
+}
+
+module.exports = {
+    formatarAnalise,
+    formatarExecucao
+}

package/src/generators/index.js

@@ -0,0 +1,27 @@
+const fs = require("fs")
+const path = require("path")
+
+function formatDependencies(deps) {
+    if (!deps || Object.keys(deps).length === 0) {
+        return "No dependencies found.\n";
+    }
+
+    return Object.entries(deps)
+        .map(([name, version]) => `- ${name} ${version}`)
+        .join("\n");
+}
+
+function formatScripts(scripts) {
+    if (!scripts || Object.keys(scripts).length === 0) {
+        return "No scripts available.\n";
+    }
+
+    return Object.entries(scripts)
+        .map(([name, script]) => `- ${name} -> ${script}`)
+        .join("\n");
+}
+
+module.exports = {
+formatDependencies,
+formatScripts
+}

package/src/interactive/index.js

@@ -0,0 +1,95 @@
+const fs = require("fs")
+const path = require("path")
+const prompts = require('prompts');
+
+async function buscarNome(nome) {
+  if (!nome) {
+    const confirm = await prompts({
+      type: 'confirm',
+      name: 'value',
+      message: 'Project name not found in package.json. Provide one?',
+      initial: true
+    });
+
+    if (!confirm.value) {
+      console.log("\nProject name will be set as Unnamed Project.\n");
+      return "Unnamed Project";
+    }
+
+    const response = await prompts({
+      type: 'text',
+      name: 'value',
+      message: 'Enter the project name:'
+    });
+
+    console.log(`\nProject name set to "${response.value}".\n`);
+    return response.value || "Unnamed Project";
+  }
+
+  return nome;
+}
+
+async function buscarDescricao(descricao) {
+  if (!descricao) {
+    const confirm = await prompts({
+      type: 'confirm',
+      name: 'value',
+      message: 'Project description not found. Provide one?',
+      initial: true
+    });
+
+    if (!confirm.value) {
+      console.log("\nDescription placeholder added.\n");
+      return "*Project description goes here*";
+    }
+
+    const response = await prompts({
+      type: 'text',
+      name: 'value',
+      message: 'Enter the project description:'
+    });
+
+    console.log("\nDescription saved.\n");
+    return response.value || "*Project description goes here*";
+  }
+
+  return descricao;
+}
+
+async function escolherLingua() {
+  const response = await prompts({
+    type: 'select',
+    name: 'lang',
+    message: 'Choose README language',
+    choices: [
+      { title: 'English', value: 'en' },
+      { title: 'Português', value: 'pt' },
+      { title: 'Español', value: 'es' }
+    ],
+    initial: 0
+  });
+
+  return response.lang || 'en';
+}
+
+
+async function perguntarPortaManual() {
+  const response = await prompts({
+    type: "text",
+    name: "port",
+    message: "⚠️  Could not automatically detect the port.\nEnter the API port (or leave empty to skip):",
+    validate: value => {
+      if (!value) return true
+      return /^\d+$/.test(value) || "Please enter numbers only"
+    }
+  })
+
+  return response.port || null
+}
+
+module.exports = {
+buscarNome,
+buscarDescricao,
+escolherLingua,
+perguntarPortaManual
+}