mdsmith 1.1.2 → 1.2.1

package/bin/vers/303/243o2.js

@@ -0,0 +1,997 @@
+#!/usr/bin/env node
+
+// npx mdsmith --help     # show help
+// npx mdsmith --init     # create config file
+// npx mdsmith --tree     # show project structure
+// npx mdsmith --deps     # list dependencies
+// npx mdsmith --readme   # generate README
+// npx mdsmith --analyze  # project analyze
+
+
+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"
+}
+
+
+const i18n = {
+  en: {
+    projectInfo: "Project Info",
+    dependencies: "Dependencies",
+    projectStructure: "Project Structure",
+    availableScripts: "Available Scripts",
+    version: "Version",
+    packageManager: "Package Manager",
+    type: "Type",
+    generatedBy: "Generated by"
+  },
+  pt: {
+    projectInfo: "Informações do Projeto",
+    dependencies: "Dependências",
+    projectStructure: "Estrutura do Projeto",
+    availableScripts: "Scripts Disponíveis",
+    version: "Versão",
+    packageManager: "Gerenciador de Pacotes",
+    type: "Tipo",
+    generatedBy: "Gerado por"
+  },
+  es: {
+    projectInfo: "Información del Proyecto",
+    dependencies: "Dependencias",
+    projectStructure: "Estructura del Proyecto",
+    availableScripts: "Scripts Disponibles",
+    version: "Versión",
+    packageManager: "Administrador de Paquetes",
+    type: "Tipo",
+    generatedBy: "Generado por"
+  }
+}
+
+const fs = require("fs");
+
+const path = require("path");
+
+const prompts = require('prompts');
+
+const projectRoot = process.cwd();
+
+if(!fs.existsSync(path.join(process.cwd(), "package.json"))){
+    console.log(`
+Error: package.json not found.
+Please run mdsmith from the project root.  
+    `)
+    process.exit(1)
+}
+
+let packageJson
+
+try {
+  packageJson = JSON.parse(
+    fs.readFileSync(path.join(projectRoot, "package.json"), "utf-8")
+  )
+} catch {
+  console.log("Invalid package.json file.")
+  process.exit(1)
+}
+
+const args = process.argv.slice(2)
+
+const defaultConfig = {
+  ignore: ["node_modules", ".git", ".vscode"],
+  depth: Infinity,
+  emojis: true
+}
+
+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 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 scanDir(dirPath, padding, config) { 
+      let entries
+      try {
+        entries = fs.readdirSync(dirPath, { withFileTypes: true })
+          .sort((a, b) => {
+              if (a.isDirectory() && !b.isDirectory()) return -1
+              if (!a.isDirectory() && b.isDirectory()) return 1
+              return a.name.localeCompare(b.name)
+          })
+      } catch {
+        return ""
+      }
+
+    let treeContent = ""
+
+    
+    for (const entry of entries) { 
+        
+        const fullPath = path.join(dirPath, entry.name); 
+        
+        if (entry.isDirectory()) { 
+            if (config.ignore.includes(entry.name)){
+                continue
+            } else {
+                treeContent += `${" ".repeat(padding*2)} 📂 ${entry.name}\n`
+                if (config.depth === null || padding < config.depth){
+                    padding ++
+                    treeContent += scanDir(fullPath, padding, config)
+                    padding --
+                } else {
+                    treeContent += `${" ".repeat((padding + 1) * 2)} ··· \n`
+                }
+            }
+        } else { 
+            if (config.ignore.includes(entry.name)){
+                continue
+            } else{
+                treeContent += `${" ".repeat(padding*2)} 📄 ${entry.name}\n`
+            }
+        } 
+    } 
+
+    return treeContent
+}
+
+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;
+}
+
+function detectarTipoProjeto(packageJson) {
+    const deps = {
+        ...packageJson.dependencies,
+        ...packageJson.devDependencies
+    }
+
+    if (deps.react) return "Frontend React"
+    if (deps.next) return "Next.js Application"
+    if (deps.express) return "API REST (Express)"
+    if (deps.typescript) return "Projeto TypeScript"
+
+    return "Node.js Project"
+}
+
+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");
+}
+
+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 gerarEnvSection(vars) {
+  if (!vars.length) return ""
+
+  let section = "## 🔑 Environment Variables\n\n"
+  section += "Create a `.env` file in the project root with the following variables:\n\n"
+
+  vars.forEach(v => {
+    section += `- ${v}\n`
+  })
+
+  return section + "\n"
+}
+
+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
+}
+
+async function perguntarPortaManual() {
+  const response = await prompts({
+    type: "text",
+    name: "port",
+    message: "⚠️  Não consegui detectar a porta automaticamente.\nDigite a porta da API (ou deixe vazio para pular):",
+    validate: value => {
+      if (!value) return true
+      return /^\d+$/.test(value) || "Digite apenas números"
+    }
+  })
+
+  return response.port || null
+}
+
+function scanProjectFiles(projectRoot) {
+  const result = {
+    allFiles: [],
+    jsFiles: [],
+    tsFiles: [],
+    envFiles: [],
+    hasDockerfile: false,
+    hasPrisma: false,
+    hasSrcFolder: false,
+  }
+
+  function walk(dir) {
+    let files
+    try {
+      files = fs.readdirSync(dir)
+    } catch {
+      return
+    }
+
+    for (const file of files) {
+      const fullPath = path.join(dir, file)
+
+      // ignorar node_modules e .git
+      if (
+        fullPath.includes("node_modules") ||
+        fullPath.includes(".git")
+      ) continue
+
+      let stat
+      try {
+        const stat = fs.lstatSync(fullPath)
+
+        if (stat.isSymbolicLink()) continue
+      } catch {
+        continue
+      }
+
+      if (stat.isDirectory()) {
+        if (file === "src") {
+          result.hasSrcFolder = true
+        }
+        walk(fullPath)
+      } else {
+        result.allFiles.push(fullPath)
+
+        if (file.endsWith(".js")) result.jsFiles.push(fullPath)
+        if (file.endsWith(".ts")) result.tsFiles.push(fullPath)
+        if (file.startsWith(".env")) result.envFiles.push(fullPath)
+
+        if (file === "Dockerfile") result.hasDockerfile = true
+        if (fullPath.includes("prisma")) result.hasPrisma = true
+      }
+    }
+  }
+
+  walk(projectRoot)
+
+  return result
+}
+
+function gerarGettingStarted(packageManager = "npm", scripts = {}, hasPrisma) {
+  const lines = []
+
+  lines.push(
+    packageManager === "npm"
+      ? "npm install"
+      : `${packageManager} install`
+  )
+
+  if (hasPrisma) {
+    lines.push("npx prisma migrate dev")
+  }
+
+  if (scripts.dev) {
+    lines.push(getRunCommand("dev", packageManager))
+  } else if (scripts.start) {
+    lines.push(getRunCommand("start", packageManager))
+  }
+
+  return `
+## 🚀 Getting Started
+
+\`\`\`bash
+${lines.join("\n")}
+\`\`\`
+
+`
+}
+
+
+function getRunCommand(script, packageManager) {
+  if (packageManager === "yarn") return `yarn ${script}`
+  if (packageManager === "pnpm") return `pnpm ${script}`
+  return `npm run ${script}`
+}
+
+
+
+async function generateReadme(packageJson, tree, config){
+
+  const deps = {
+    ...packageJson.dependencies,
+    ...packageJson.devDependencies
+  }
+
+  const techStack = detectarTechStack(deps)
+  const techSection = gerarTechStackSection(techStack)
+
+
+
+
+  const envVars = detectarEnvVars(projectRoot)
+  const envSection = gerarEnvSection(envVars)
+
+  const nomeProjeto = await buscarNome(packageJson.name);
+  const descricaoProjeto = await buscarDescricao(packageJson.description);
+  const idioma = await escolherLingua()
+  const t = i18n[idioma] || i18n.en
+
+  const packageManager = detectarPackageManager(projectRoot)
+
+  const scanData = scanProjectFiles(projectRoot)
+  let port = detectarPorta(scanData)
+
+  if (!port) {
+    port = await perguntarPortaManual()
+  }
+
+  const commands = analisarScripts(packageJson.scripts, packageManager)
+
+  const hasPrisma = detectarPrisma(projectRoot, packageJson)
+  const dbSection = hasPrisma ? gerarDatabaseSection(packageManager) : ""
+
+  const gettingStartedCommands = gerarGettingStarted(
+    packageManager,
+    packageJson.scripts,
+    hasPrisma
+  )
+
+
+
+const content = `
+# ${nomeProjeto}
+
+${descricaoProjeto}
+
+## ${config.emojis ? "🔖" : ""} ${t.projectInfo}
+- **${t.version}:** ${packageJson.version || "Not specified"}
+- **${t.packageManager}:** ${packageManager}
+- **${t.type}:** ${detectarTipoProjeto(packageJson)}
+
+${techSection}
+
+## ${config.emojis ? "📁" : ""} ${t.projectStructure}
+\`\`\`
+${tree}
+\`\`\`
+
+${gettingStartedCommands}
+
+${envSection}
+${dbSection}
+
+${port ? `
+## 🌐 Server
+
+After starting, the server will run at:
+
+http://localhost:${port}
+
+` : ""}
+
+
+---
+
+${t.generatedBy} **mdSmith**
+`
+    
+    return content 
+
+}
+
+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
+}
+
+function gerarDatabaseSection(packageManager) {
+  let section = "## 🗄 Database Setup\n\n"
+  section += "Run Prisma migrations:\n\n"
+  section += "```bash\n"
+
+  if (packageManager === "npm") {
+    section += "npx prisma migrate dev\n"
+    section += "npx prisma generate\n"
+  } else {
+    section += "npx prisma migrate dev\n"
+    section += "npx prisma generate\n"
+  }
+
+  section += "```\n\n"
+
+  return section
+}
+
+
+
+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';
+}
+
+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
+  }
+}
+
+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: 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 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 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
+}
+
+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 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 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 gerarTechStackSection(stack) {
+  if (!stack.length) return ""
+
+  let section = "## 🛠 Tech Stack\n\n"
+
+  stack.forEach(tech => {
+    section += `- ${tech}\n`
+  })
+
+  return section + "\n"
+}
+
+
+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()
+  }
+}
+
+
+
+async function main() {
+    const config = loadConfig(projectRoot)
+
+    if(args.length == 0){
+        console.log(`
+mdSmith
+Node.js project analyzer
+────────────────────────
+
+Run "mdsmith --help" to view available commands.
+        `);
+        process.exit(0);
+    }else if (args.includes("--init")) {
+
+        const configPath = path.join(projectRoot, "mdsmith.config.json")
+
+        if (fs.existsSync(configPath)) {
+            console.log("mdsmith.config.json already exists.")
+            process.exit(0)
+        }
+
+        fs.writeFileSync(
+            configPath,
+            JSON.stringify(defaultConfig, null, 2)
+        )
+
+        console.log("Configuration file created.")
+        process.exit(0)
+
+    } else if(args.includes("--help")){
+        console.log(`
+mdSmith — Available Commands
+────────────────────────
+
+    --help      Show help
+    --init      Create config file
+    --tree      Show project structure
+    --deps      List dependencies
+    --readme    Generate README
+    --analyze   Project analysis
+        `)  
+        process.exit(0)
+    } else if (args.includes("--tree")){
+        console.log(`
+Project Structure
+────────────────────────
+        `);
+        console.log(scanDir(projectRoot, 0, config))
+        process.exit(0)
+    } else if (args.includes("--analyze")){
+      const analysis = analisarProjeto(packageJson, projectRoot)
+      const packageManager = detectarPackageManager(projectRoot)
+
+      formatarAnalise(analysis)
+
+      const commands = analisarScripts(packageJson.scripts, packageManager)
+      const warnings = diagnosticarExecucao(commands)
+
+      formatarExecucao(commands, warnings)
+
+      const issues = healthChecks(packageJson, projectRoot, analysis)
+
+      if (issues.length > 0) {
+          console.log("Health Checks")
+          console.log("────────────────────────")
+          issues.forEach(issue => {
+            let icon = "⚠"
+
+            if (issue.type === "critical") icon = "❌"
+            if (issue.type === "info") icon = "ℹ"
+
+            console.log(`${icon} ${issue.message}`)
+          })
+          console.log()
+      }
+
+      process.exit(0)
+    } else if (args.includes("--deps")){
+        console.log(`
+Dependencies
+────────────────────────   
+        `)
+        const deps = formatDependencies(packageJson.dependencies)
+        console.log(`${deps}\n`)
+        console.log()
+        process.exit(0)
+    } else if (args.includes("--readme")){
+        const content = await generateReadme(packageJson, scanDir(projectRoot, 0, config), config)
+
+        console.log(`
+README Preview
+────────────────────────
+        `)
+
+        console.log(content)
+
+        const confirmResponse = await prompts({
+            type: 'confirm',
+            name: 'generate',
+            message: 'Generate README-MDSMITH.md?',
+            initial: true
+        });
+
+        if (confirmResponse.generate) {
+            fs.writeFileSync("README-MDSMITH.md", content);
+            console.log("\nREADME-MDSMITH.md created.\n");
+        } else {
+            console.log("\nOperation cancelled.\n");
+        }
+
+        process.exit(0);
+
+    } else {
+        console.log(`
+Unknown command.
+Run "mdsmith --help" for usage.    
+        `)
+        process.exit(0)
+    }
+}
+
+main()
+