@flowdevcli/flowdev 1.0.0

package/src/commands/devops/env.js

@@ -0,0 +1,125 @@
+import fs from 'fs-extra';
+import path from 'path';
+import chalk from 'chalk';
+import ora from 'ora';
+import { logger } from '../../utils/logger.js';
+
+const SCAN_EXTENSIONS = ['.js', '.jsx', '.ts', '.tsx', '.vue', '.svelte', '.json', '.php', '.py', '.go', '.java'];
+const IGNORE_DIRS = ['node_modules', '.git', 'dist', 'build', 'coverage', '.next', 'vendor'];
+
+
+async function getFiles(dir) {
+  const subdirs = await fs.readdir(dir);
+  const files = await Promise.all(subdirs.map(async (subdir) => {
+    const res = path.resolve(dir, subdir);
+    
+    if (IGNORE_DIRS.includes(subdir)) return [];
+
+    const stat = await fs.stat(res);
+    
+    if (stat.isDirectory()) {
+      return getFiles(res); 
+    } else {
+      
+      if (SCAN_EXTENSIONS.includes(path.extname(res))) {
+        return res;
+      }
+      return [];
+    }
+  }));
+  return files.reduce((a, f) => a.concat(f), []);
+}
+
+function extractEnvVars(content) {
+  const vars = new Set();
+  
+ 
+  const regex = /\b(?:process\.env\.|import\.meta\.env\.|process\.env\[['"])([A-Z_][A-Z0-9_]*)\b/g;
+  
+  let match;
+  while ((match = regex.exec(content)) !== null) {
+   
+    if (match[1] && match[1] !== 'NODE_ENV') { 
+      vars.add(match[1]);
+    }
+  }
+  
+  return Array.from(vars);
+}
+
+export async function envCommand() {
+  const spinner = ora(chalk.cyan('Scanning project for environment variables...')).start();
+
+  try {
+    const rootDir = process.cwd();
+    
+    
+    const files = await getFiles(rootDir);
+    spinner.text = chalk.cyan(`Analyzing ${files.length} files...`);
+
+    const allEnvVars = new Set();
+
+    
+    for (const file of files) {
+      try {
+        const content = await fs.readFile(file, 'utf-8');
+        const vars = extractEnvVars(content);
+        vars.forEach(v => allEnvVars.add(v));
+      } catch (err) {
+       
+      }
+    }
+
+    if (allEnvVars.size === 0) {
+      spinner.warn(chalk.yellow('No environment variables found in code.'));
+      return;
+    }
+
+    
+    const sortedVars = Array.from(allEnvVars).sort();
+    let envContent = `# Auto-generated by FlowDev\n# Environment Variables Example\n\n`;
+    
+    sortedVars.forEach(variable => {
+      envContent += `${variable}=\n`;
+    });
+
+    const outputPath = path.join(rootDir, '.env.example');
+
+    if (await fs.pathExists(outputPath)) {
+
+        const oldContent = await fs.readFile(outputPath, 'utf-8');
+        const existingLines = oldContent.split('\n');
+        
+        let newCount = 0;
+        let appendContent = "\n# New variables detected by FlowDev:\n";
+        
+        sortedVars.forEach(variable => {
+            if (!oldContent.includes(variable + '=')) {
+                appendContent += `${variable}=\n`;
+                newCount++;
+            }
+        });
+
+        if (newCount > 0) {
+            await fs.appendFile(outputPath, appendContent);
+            spinner.succeed(chalk.green(`Updated .env.example with ${newCount} new variables!`));
+        } else {
+            spinner.succeed(chalk.green('.env.example is already up to date.'));
+        }
+
+    } else {
+       
+        await fs.writeFile(outputPath, envContent);
+        spinner.succeed(chalk.green(`Created .env.example with ${allEnvVars.size} variables!`));
+    }
+
+   
+    console.log(chalk.gray('\nDetected variables:'));
+    sortedVars.forEach(v => console.log(chalk.blue(`- ${v}`)));
+    console.log('');
+
+  } catch (error) {
+    spinner.stop();
+    logger.error(`Error generating .env file: ${error.message}`);
+  }
+}

package/src/commands/devops/kube.js

@@ -0,0 +1,87 @@
+import fs from 'fs-extra';
+import path from 'path';
+import chalk from 'chalk';
+import ora from 'ora';
+
+export async function kubeCommand() {
+  const rootDir = process.cwd();
+  const spinner = ora(chalk.cyan('Checking project readiness...')).start();
+
+  try {
+    const projectName = path.basename(rootDir).toLowerCase().replace(/[^a-z0-9]/g, '-');
+    let port = 3000; 
+    let hasDockerfile = await fs.pathExists(path.join(rootDir, 'Dockerfile'));
+
+    
+    if (hasDockerfile) {
+      const dockerfile = await fs.readFile('Dockerfile', 'utf-8');
+      const exposeMatch = dockerfile.match(/EXPOSE\s+(\d+)/);
+      if (exposeMatch) port = exposeMatch[1];
+      spinner.text = chalk.blue('Docker configuration detected. Syncing ports...');
+    } else {
+      
+      spinner.text = chalk.yellow('No Dockerfile found. Using smart defaults...');
+      if (await fs.pathExists('package.json')) {
+        const pkg = await fs.readJson('package.json');
+       
+      }
+    }
+
+    spinner.text = chalk.magenta('Generating Kubernetes Manifests...');
+
+    const k8sContent = `
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+  name: ${projectName}
+spec:
+  replicas: 2
+  selector:
+    matchLabels:
+      app: ${projectName}
+  template:
+    metadata:
+      labels:
+        app: ${projectName}
+    spec:
+      containers:
+      - name: ${projectName}
+        image: ${projectName}:latest 
+        ports:
+        - containerPort: ${port}
+---
+apiVersion: v1
+kind: Service
+metadata:
+  name: ${projectName}-service
+spec:
+  selector:
+    app: ${projectName}
+  ports:
+    - protocol: TCP
+      port: 80
+      targetPort: ${port}
+  type: LoadBalancer
+`.trim();
+
+    await fs.writeFile(path.join(rootDir, 'k8s.yaml'), k8sContent);
+    
+    spinner.succeed(chalk.green('Kubernetes manifests generated!'));
+
+    
+    if (!hasDockerfile) {
+      console.log(chalk.yellow(`\n  Warning: No Dockerfile found in this directory.`));
+      console.log(`Kubernetes needs a Docker image to run your app.`);
+      console.log(`Recommended: Run ${chalk.bold('flowdev dockerize')} first.`);
+    }
+
+    console.log(chalk.gray('\nConfiguration details:'));
+    console.log(`${chalk.blue('→ Deployment Name:')} ${projectName}`);
+    console.log(`${chalk.blue('→ Target Port:')} ${port}`);
+    console.log(`\nNext: ${chalk.yellow('kubectl apply -f k8s.yaml')}`);
+
+  } catch (error) {
+    spinner.fail(chalk.red('Kube generation failed.'));
+    console.error(error);
+  }
+}

package/src/commands/scaffold/find.js

@@ -0,0 +1,118 @@
+import fs from 'fs-extra';
+import path from 'node:path';
+import chalk from 'chalk';
+import { createInterface } from 'node:readline';
+import ora from 'ora';
+
+
+const IGNORED_DIRS = new Set(['node_modules', '.git', 'dist', 'build', '.next', 'coverage', '.idea', '.vscode']);
+
+
+const BINARY_EXTS = new Set([
+  '.png', '.jpg', '.jpeg', '.gif', '.ico', '.svg', 
+  '.pdf', '.zip', '.tar', '.gz', '.7z', '.rar',
+  '.exe', '.bin', '.dll', '.so', '.dylib', 
+  '.lock', '.pyc', '.mp3', '.mp4'
+]);
+
+export async function findCommand(pattern, options) {
+  let targetExtensions = null;
+  if (options.ext) {
+    targetExtensions = new Set(
+      options.ext.split(',').map(e => {
+        let clean = e.trim().toLowerCase();
+        clean = clean.replace('*', ''); 
+        return clean.startsWith('.') ? clean : '.' + clean;
+      })
+    );
+  }
+
+  const searchRegex = new RegExp(pattern, 'i');
+  const spinner = ora(`Search for "${chalk.cyan(pattern)}"...`).start();
+  
+  let matchCount = 0;
+  let fileCount = 0;
+  const startDir = process.cwd();
+
+  try {
+    await scanDirectory(startDir);
+    
+    spinner.stop();
+    
+    if (matchCount === 0) {
+      console.log(chalk.yellow(`No results for "${pattern}".`));
+    } else {
+      console.log(chalk.green(`\nDone ! ${matchCount} occurrences found in ${fileCount} scanned files.`));
+    }
+    console.log('\n');
+
+  } catch (err) {
+    spinner.fail('Error during search');
+    console.error(err);
+  }
+
+ 
+
+  async function scanDirectory(dir) {
+    try {
+      const entries = await fs.readdir(dir, { withFileTypes: true });
+
+      for (const entry of entries) {
+        const fullPath = path.join(dir, entry.name);
+
+        if (entry.isDirectory()) {
+          if (!IGNORED_DIRS.has(entry.name)) {
+            await scanDirectory(fullPath);
+          }
+        } else if (entry.isFile()) {
+          const ext = path.extname(entry.name).toLowerCase();
+
+          let shouldScan = false;
+
+          if (targetExtensions) {
+            if (targetExtensions.has(ext)) shouldScan = true;
+          } else {
+            if (!BINARY_EXTS.has(ext)) shouldScan = true;
+          }
+
+          if (shouldScan) {
+            fileCount++;
+            await searchInFile(fullPath);
+          }
+        }
+      }
+    } catch (e) {
+      
+    }
+  }
+
+  async function searchInFile(filePath) {
+    const fileStream = fs.createReadStream(filePath);
+    
+    const rl = createInterface({
+      input: fileStream,
+      crlfDelay: Infinity
+    });
+
+    let lineNum = 0;
+    let foundInFile = false;
+
+    for await (const line of rl) {
+      lineNum++;
+      
+      
+      if (searchRegex.test(line)) {
+        matchCount++;
+        
+        if (!foundInFile) {
+          const relativePath = path.relative(startDir, filePath);
+          console.log(chalk.bold.blue(`\n ${relativePath}`));
+          foundInFile = true;
+        }
+
+        const highlightedLine = line.replace(searchRegex, (match) => chalk.bgYellow.black(match));
+        console.log(`  ${chalk.gray(lineNum.toString().padEnd(4))} │ ${highlightedLine.trim()}`);
+      }
+    }
+  }
+}

package/src/commands/scaffold/generate.js

@@ -0,0 +1,247 @@
+import fs from 'fs-extra';
+import path from 'path';
+import chalk from 'chalk';
+import ora from 'ora';
+import inquirer from 'inquirer';
+import { execSync } from 'child_process';
+import { logger } from '../../utils/logger.js';
+
+const pythonCmd = process.platform === 'win32' ? 'python' : 'python3';
+const npmCmd = process.platform === 'win32' ? 'npm.cmd' : 'npm';
+const npxCmd = process.platform === 'win32' ? 'npx.cmd' : 'npx';
+
+
+const PYTHON_REGEX = /^[a-zA-Z_][a-zA-Z0-9_]*$/;
+const GENERAL_REGEX = /^[a-zA-Z][a-zA-Z0-9-_]*$/;
+
+export async function generateCommand() {
+  const answers = await inquirer.prompt([
+    {
+      type: 'list',
+      name: 'type',
+      message: 'Choose your project template:',
+      choices: [
+        { name: 'React + Tailwind (Vite)', value: 'react-tailwind' },
+        { name: 'Vue + Tailwind (Vite)', value: 'vue-tailwind' },
+        { name: 'Django (Project + App + Venv)', value: 'django' },
+        { name: 'Angular (Workspace)', value: 'angular' },
+        { name: 'Express API (Minimal)', value: 'express' }
+      ]
+    },
+    {
+      type: 'input',
+      name: 'projectName',
+      message: 'Project name:',
+      default: 'my_flow_app',
+      validate: (input, currentAnswers) => {
+        const name = input.trim();
+        if (!name) return 'A name is required.';
+
+        if (/^\d/.test(name)) {
+          return ' Name cannot start with a number. Please use a letter.';
+        }
+
+      
+        if (currentAnswers.type === 'django') {
+          if (!PYTHON_REGEX.test(name)) {
+            return ' Django projects cannot contain dashes (-) or spaces. Use underscores (_) instead.';
+          }
+        } 
+       
+        else {
+          if (!GENERAL_REGEX.test(name)) {
+            return ' Invalid name. Use letters, numbers, dashes (-) or underscores (_).';
+          }
+        }
+
+        return true;
+      }
+    }
+  ]);
+
+  
+  if (answers.type === 'django') {
+    const djangoSub = await inquirer.prompt([{
+      type: 'input',
+      name: 'appName',
+      message: 'Initial app name:',
+      default: 'core',
+      validate: (input) => {
+        const name = input.trim();
+        
+        if (!PYTHON_REGEX.test(name)) {
+          return ' Invalid Python App name. Must start with a letter and contain no dashes.';
+        }
+        return true;
+      }
+    }]);
+    answers.appName = djangoSub.appName;
+  }
+
+  const projectDir = path.resolve(process.cwd(), answers.projectName);
+  
+  if (await fs.pathExists(projectDir)) {
+    logger.error(`Error: Directory "${answers.projectName}" already exists.`);
+    return;
+  }
+
+  const spinner = ora(chalk.magenta('Generating your project...')).start();
+
+  try {
+    switch (answers.type) {
+      case 'react-tailwind': await setupVite(projectDir, answers.projectName, 'react', true, spinner); break;
+      case 'vue-tailwind': await setupVite(projectDir, answers.projectName, 'vue', true, spinner); break;
+      case 'django': await setupDjango(projectDir, answers, spinner); break;
+      case 'angular': await setupAngular(projectDir, answers.projectName, spinner); break;
+      case 'express': await setupExpress(projectDir, answers.projectName, spinner); break;
+    }
+
+    await initGit(projectDir, spinner);
+
+    spinner.succeed(chalk.green(`Project "${answers.projectName}" is ready and configured!`));
+    showSuccessTips(answers);
+
+  } catch (error) {
+    spinner.fail(chalk.red('Generation failed.'));
+    console.error(chalk.red(`\nDetailed Error: ${error.message}`));
+  }
+}
+
+
+
+async function setupVite(dir, name, framework, withTailwind, spinner) {
+  spinner.text = `Scaffolding ${framework} with Vite...`;
+  execSync(`${npmCmd} create vite@latest "${name}" -- --template ${framework}`, { stdio: 'ignore' });
+  
+  const originalDir = process.cwd();
+  process.chdir(dir);
+
+  spinner.text = 'Installing core dependencies...';
+  execSync(`${npmCmd} install`, { stdio: 'ignore' });
+
+  const folders = ['components', 'services', 'utils', 'hooks', 'assets'];
+  for (const f of folders) await fs.ensureDir(path.join(dir, 'src', f));
+
+  if (withTailwind) {
+    spinner.text = 'Installing & Configuring Tailwind CSS (Manual Setup)...';
+    execSync(`${npmCmd} install -D tailwindcss postcss autoprefixer`, { stdio: 'ignore' });
+
+    const tailwindConfig = `/** @type {import('tailwindcss').Config} */
+export default {
+  content: [
+    "./index.html",
+    "./src/**/*.{js,ts,jsx,tsx,vue}",
+  ],
+  theme: {
+    extend: {},
+  },
+  plugins: [],
+}`;
+    await fs.writeFile(path.join(dir, 'tailwind.config.js'), tailwindConfig);
+
+    const postcssConfig = `export default {
+  plugins: {
+    tailwindcss: {},
+    autoprefixer: {},
+  },
+}`;
+    await fs.writeFile(path.join(dir, 'postcss.config.js'), postcssConfig);
+
+    const cssPath = path.join(dir, 'src', 'index.css');
+    const tailwindDirectives = `@tailwind base;\n@tailwind components;\n@tailwind utilities;\n\n`;
+    
+    let currentCss = "";
+    if (await fs.pathExists(cssPath)) {
+        currentCss = await fs.readFile(cssPath, 'utf-8');
+    }
+    await fs.writeFile(cssPath, tailwindDirectives + currentCss);
+  }
+
+  process.chdir(originalDir);
+}
+
+async function setupDjango(dir, data, spinner) {
+  const { projectName, appName } = data;
+  const isWin = process.platform === 'win32';
+  
+  await fs.ensureDir(dir);
+  const originalDir = process.cwd();
+  process.chdir(dir);
+
+  try {
+    spinner.text = 'Creating virtual environment...';
+    execSync(`${pythonCmd} -m venv venv`, { stdio: 'ignore' });
+
+    const venvPython = isWin 
+      ? path.join(dir, 'venv', 'Scripts', 'python.exe') 
+      : path.join(dir, 'venv', 'bin', 'python');
+
+    spinner.text = 'Installing Django...';
+    execSync(`"${venvPython}" -m pip install django`, { stdio: 'ignore' });
+
+    spinner.text = 'Initializing Django project...';
+    
+    execSync(`"${venvPython}" -m django startproject config .`, { stdio: 'ignore' });
+
+    spinner.text = `Creating app: ${appName}...`;
+    execSync(`"${venvPython}" manage.py startapp ${appName}`, { stdio: 'ignore' });
+
+    await fs.writeFile(path.join(dir, appName, 'urls.py'), 
+      `from django.urls import path\nfrom . import views\n\nurlpatterns = [ path('', views.index, name='index'), ]`);
+    
+    await fs.writeFile(path.join(dir, appName, 'views.py'), 
+      `from django.http import HttpResponse\n\ndef index(request):\n    return HttpResponse("<h1>${projectName} is live!</h1>")`);
+
+  } finally {
+    process.chdir(originalDir);
+  }
+}
+
+async function initGit(dir, spinner) {
+  try {
+    spinner.text = 'Initializing Git...';
+    const ignorePath = path.join(dir, '.gitignore');
+    if (!(await fs.pathExists(ignorePath))) {
+      const defaultIgnore = 'node_modules\n.env\ndist\nbuild\n__pycache__\n*.log\nvenv\n.venv\n';
+      await fs.writeFile(ignorePath, defaultIgnore);
+    }
+    const originalDir = process.cwd();
+    process.chdir(dir);
+    execSync('git init', { stdio: 'ignore' });
+    execSync('git add .', { stdio: 'ignore' });
+    execSync('git commit -m "Initial commit by FlowDev 🚀"', { stdio: 'ignore' });
+    process.chdir(originalDir);
+  } catch (err) {
+    spinner.warn(chalk.yellow('Git initialization skipped.'));
+  }
+}
+
+async function setupAngular(dir, name, spinner) {
+  spinner.text = 'Generating Angular Workspace...';
+  
+  execSync(`${npxCmd} --yes -p @angular/cli ng new "${name}" --defaults --skip-git`, { stdio: 'ignore' });
+}
+
+async function setupExpress(dir, name, spinner) {
+  spinner.text = 'Setting up Express...';
+  await fs.ensureDir(dir);
+  const pkg = { name, version: '1.0.0', scripts: { start: 'node src/index.js' }, dependencies: { express: '^4.18.2', cors: '^2.8.5' }};
+  await fs.writeJson(path.join(dir, 'package.json'), pkg, { spaces: 2 });
+  await fs.ensureDir(path.join(dir, 'src'));
+  await fs.writeFile(path.join(dir, 'src', 'index.js'), `const express = require('express');\nconst app = express();\napp.get('/', (req, res) => res.send('API OK'));\napp.listen(3000);`);
+  process.chdir(dir);
+  execSync(`${npmCmd} install`, { stdio: 'ignore' });
+}
+
+function showSuccessTips(data) {
+  console.log(chalk.yellow('\n  Tips :'));
+  console.log(`${chalk.white('*')} cd ${chalk.bold(data.projectName)}`);
+  if (data.type.includes('tailwind')) {
+    console.log(`${chalk.green('*')} Tailwind & PostCSS are manually configured.`);
+    console.log(`${chalk.white('*')} Run: ${chalk.bold('npm run dev')}`);
+  } else if (data.type === 'django') {
+    console.log(`${chalk.white('*')} Run: ${chalk.bold('python manage.py runserver')}`);
+  } else {
+    console.log(`${chalk.white('*')} Run: ${chalk.bold('npm start')}`);
+  }
+}

package/src/commands/scaffold/readme.js

@@ -0,0 +1,54 @@
+import ollama from 'ollama';
+import chalk from 'chalk';
+import ora from 'ora';
+import fs from 'fs-extra';
+import path from 'path';
+import { ensureEngineReady } from '../../utils/engine-check.js';
+import { logger } from '../../utils/logger.js';
+
+export async function readmeCommand() {
+  const spinner = ora(chalk.cyan('Reading project structure...')).start();
+
+  try {
+    const rootDir = process.cwd();
+    let projectInfo = "";
+
+    
+    if (await fs.pathExists(path.join(rootDir, 'package.json'))) {
+      const pkg = await fs.readJson(path.join(rootDir, 'package.json'));
+      projectInfo += `Type: Node.js/Web, Name: ${pkg.name}, Deps: ${Object.keys(pkg.dependencies || {}).join(', ')}`;
+    } else if (await fs.pathExists(path.join(rootDir, 'manage.py'))) {
+      projectInfo += `Type: Django/Python project`;
+    }
+
+    await ensureEngineReady(spinner, 'llama3');
+
+    spinner.text = chalk.magenta('Drafting your documentation...');
+
+    
+    const prompt = `
+      You are a technical writer. Generate a professional README.md for a project with these details: ${projectInfo}.
+      The README should include:
+      - A catchy title with an emoji.
+      - A brief description.
+      - Installation steps.
+      - How to run the project.
+      - Tech stack used.
+      
+      Return ONLY the markdown content.
+    `;
+
+    const response = await ollama.chat({
+      model: 'llama3.2',
+      messages: [{ role: 'user', content: prompt }],
+    });
+    const readmePath = path.join(rootDir, 'README.md');
+    await fs.writeFile(readmePath, response.message.content);
+
+    spinner.succeed(chalk.green('README.md generated successfully! '));
+
+  } catch (error) {
+    spinner.fail(chalk.red('Failed to generate README.'));
+    logger.error(error.message);
+  }
+}

package/src/commands/system/update.js

@@ -0,0 +1,35 @@
+import chalk from "chalk";
+import { execSync } from "child_process";
+import path from "path";
+import { fileURLToPath } from "url";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+export async function updateCommand() {
+    const spinner = ora(chalk.cyan('Checking for update ...')).start();
+
+    try {
+        const packageJsonPath = path.resolve(__dirname, '../../../package.json');
+        const pkg = await fstat.readJson(packageJsonPath);
+
+        const currentVersion = pkg.version;
+        const packageName = pkg.name;
+        let latestVersion;
+        try {
+            latestVersion = execSync(`npm views ${packageName} version` , {encoding : 'utf-8'}).trim();
+
+        } catch(e) {
+            spinner.warn(chalk.yellow('Could not found registry'));
+        }
+
+        if (latestVersion == currentVersion) {
+            ora(chalk.green(`Flowdev is up to date ! You are already using the latest version ${currentVersion}`));
+        }
+    }
+
+    catch(error){
+
+    }
+
+}

package/src/commands/utils/stats.js

@@ -0,0 +1,27 @@
+import ora from 'ora';
+import chalk from 'chalk';
+import { analyzeProject } from '../../services/analyzer.js';
+
+
+export async function statsCommand() {
+  const spinner = ora('Analysis of the ongoing project...').start();
+  const start = Date.now();
+
+  try {
+    const stats = await analyzeProject();
+    const duration = Date.now() - start;
+
+    spinner.succeed(chalk.green(`Analysis completed in ${duration}ms !`));
+    console.log('\n' + chalk.bold.underline('Analysis results :'));
+    
+   
+    console.table(stats.languages);
+
+    console.log(`\nFiles analyzed : ${chalk.cyan(stats.totalFiles)}`);
+    console.log(` Total rows  : ${chalk.cyan(stats.totalLines)}`);
+  } catch (error) {
+    spinner.fail(chalk.red('Analysis failed.'));
+    console.error(error.message);
+  }
+}
+