@flowdevcli/flowdev 1.0.0

package/src/commands/utils/tree.js

@@ -0,0 +1,10 @@
+import chalk from 'chalk';
+import { generateTree } from '../../services/file-system.js';
+
+export async function treeCommand() {
+  console.log(chalk.bold.cyan('\nProject\' tree :'));
+  console.log(chalk.cyan('.\n'));
+  
+  const tree = await generateTree(process.cwd());
+  console.log(tree);
+}

package/src/core/cli.js

@@ -0,0 +1,113 @@
+import { program } from 'commander';
+import { createRequire } from 'node:module';
+import chalk from 'chalk';
+import { statsCommand } from '../commands/utils/stats.js';
+import { treeCommand } from '../commands/utils/tree.js';
+import { dockerizeCommand } from '../commands/devops/dockerize.js';
+import {findCommand} from '../commands/scaffold/find.js'
+import { askCommand } from '../commands/ai/ask.js';
+import { explainCommand } from '../commands/ai/explain.js';
+import { envCommand } from '../commands/devops/env.js';
+import { kubeCommand } from '../commands/devops/kube.js';
+import { generateCommand } from '../commands/scaffold/generate.js';
+import { auditCommand } from '../commands/ai/audit.js';
+import { testCommand } from '../commands/ai/test.js';
+
+
+const require = createRequire(import.meta.url);
+const pkg = require('../../package.json');
+
+export function setupCLI() {
+  program
+    .name('flowdev')
+    .description('Intelligent CLI to automate your workflow')
+    .version(pkg.version, '-v, --version', 'output the current version');
+
+
+  program
+    .command('version')
+    .description('Display the current version of FlowDev')
+    .action(() => {
+      console.log(`\n ${chalk.bold('FLOWDEV')} ${chalk.cyan('v' + pkg.version)}`);
+    });
+
+  program
+  .command('tree')
+  .description('Displays the project tree')
+  .action(treeCommand);
+
+  
+  program.on('command:*', () => {
+    console.error('Invalid command. Type "flowdev --help" to see the list.');
+    process.exit(1);
+  });
+
+  program
+  .command('dockerize')
+  .description('Automatically generates Dockerfile and docker-compose.yml')
+  .action(dockerizeCommand);
+
+   program
+    .command('stats')
+    .description('Analyzes the current project and displays code statistics')
+    .action(async () => {
+      await statsCommand();
+    });
+
+
+  program
+  .command('find <pattern>')
+  .description('Search for a text in the project')
+  .option('-e, --ext <extensions>', ' Filter by extensions(ex: js,md,json)')
+  .action((pattern, options) => findCommand(pattern, options));
+
+  program
+  .command('ask <question...>')
+  .description('Ask a question to the local AI ')
+  .action((args) => {
+    const question = args.join('');
+    askCommand(question)
+  });
+
+  program
+  .command('explain <file>')
+  .description('Analyzes and explains the contents of a source file')
+  .action(async (file) => {
+    await explainCommand(file);
+  })
+
+  program 
+  .command('env')
+  .description('Scans project code and generates a .env.example file')
+  .action(async () => {
+    await envCommand();
+  });
+
+  program
+  .command('kube')
+  .description('Generate Kubernetes deployment and service manifests')
+  .action(async () => {
+    await kubeCommand();
+  });
+
+  program
+  .command('generate')
+  .description('Generates a complete project (React, Django, Vue, etc...) with Git and dependencies')
+  .action(generateCommand);
+
+  program
+  .command('audit')
+  .description('Audit your code for bugs, security, and performance with AI')
+  .action(async () => {
+    await auditCommand();
+  });
+
+  program
+  .command('test <file>') 
+  .description('Automatically generates unit tests for a specific file')
+  .action(async (file) => {
+    await testCommand(file);
+  });
+
+  return program;
+}

package/src/services/analyzer.js

@@ -0,0 +1,77 @@
+import fs from 'node:fs/promises';
+import { createReadStream } from 'node:fs';
+import path from 'node:path';
+
+const IGNORED_DIRS = new Set(['node_modules', '.git', 'dist', 'build', 'out', 'target']);
+const SUPPORTED_EXTENSIONS = {
+  '.js': 'JavaScript',
+  '.ts': 'TypeScript',
+  '.py': 'Python',
+  '.go': 'Go',
+  '.java': 'Java',
+  '.rb': 'Ruby',
+  '.php': 'PHP',
+  '.html': 'HTML',
+  '.css': 'CSS',
+  '.json': 'JSON',
+  '.yml': 'YAML',
+  '.yaml': 'YAML'
+};
+
+const countLinesInFile = (filePath) => {
+  return new Promise((resolve) => {
+    let count = 0;
+    createReadStream(filePath)
+      .on('data', (chunk) => {
+        for (let i = 0; i < chunk.length; ++i) {
+          if (chunk[i] === 10) count++;
+        }
+      })
+      .on('end', () => resolve(count))
+      .on('error', () => resolve(0));
+  });
+};
+
+async function scanDirectory(dirPath, stats) {
+  const entries = await fs.readdir(dirPath, { withFileTypes: true });
+
+  const tasks = entries.map(async (entry) => {
+    const fullPath = path.join(dirPath, entry.name);
+
+    if (entry.isDirectory()) {
+      if (!IGNORED_DIRS.has(entry.name)) {
+        await scanDirectory(fullPath, stats);
+      }
+    } else if (entry.isFile()) {
+      const ext = path.extname(entry.name).toLowerCase();
+      if (SUPPORTED_EXTENSIONS[ext]) {
+        const lang = SUPPORTED_EXTENSIONS[ext];
+        const lines = await countLinesInFile(fullPath);
+        stats.totalFiles++;
+        stats.totalLines += lines;
+        if (!stats.languages[lang]) {
+          stats.languages[lang] = { files: 0, lines: 0 };
+        }
+        stats.languages[lang].files++;
+        stats.languages[lang].lines += lines;
+      }
+    }
+  });
+  await Promise.all(tasks);
+}
+
+export async function analyzeProject(rootPath = process.cwd()) {
+  const stats = {
+    totalFiles: 0,
+    totalLines: 0,
+    languages: {},
+    timestamp: new Date().toISOString()
+  };
+
+  try {
+    await scanDirectory(rootPath, stats);
+    return stats;
+  } catch (error) {
+    throw new Error(`Erreur lors de l'analyse du projet : ${error.message}`);
+  }
+}

package/src/services/file-system.js

@@ -0,0 +1,31 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import chalk from 'chalk';
+
+const IGNORED = new Set(['node_modules', '.git', 'dist']);
+
+export async function generateTree(dir, prefix = '') {
+  const entries = await fs.readdir(dir, { withFileTypes: true });
+  let output = '';
+
+  entries.sort((a, b) => b.isDirectory() - a.isDirectory());
+
+  for (let i = 0; i < entries.length; i++) {
+    const entry = entries[i];
+    if (IGNORED.has(entry.name)) continue;
+
+    const isLast = i === entries.length - 1;
+    const connector = isLast ? '└── ' : '├── ';
+    const name = entry.isDirectory() 
+      ? chalk.blue.bold(entry.name + '/') 
+      : chalk.white(entry.name);
+
+    output += `${prefix}${connector}${name}\n`;
+
+    if (entry.isDirectory()) {
+      const newPrefix = prefix + (isLast ? '    ' : '│   ');
+      output += await generateTree(path.join(dir, entry.name), newPrefix);
+    }
+  }
+  return output;
+}

package/src/templates/docker/templates.js

@@ -0,0 +1,40 @@
+
+export const nodeDockerfile = (version, port, command) => `
+# Stage 1: Build
+FROM node:${version}-alpine AS builder
+WORKDIR /app
+COPY package*.json ./
+RUN npm ci
+COPY . .
+
+# Stage 2: Production
+FROM node:${version}-alpine
+WORKDIR /app
+COPY --from=builder /app ./
+EXPOSE ${port}
+# Formats the command string into a JSON array for CMD
+CMD ["${command.split(' ').join('", "')}"]
+`.trim();
+
+
+export const pythonDockerfile = (version, port, startFile) => `
+FROM python:${version}-slim
+WORKDIR /app
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+COPY . .
+EXPOSE ${port}
+CMD ["python", "${startFile}"]
+`.trim();
+
+export const dockerCompose = (projectName, port) => `
+version: '3.8'
+services:
+  ${projectName}:
+    build: .
+    ports:
+      - "${port}:${port}"
+    environment:
+      - NODE_ENV=production
+    restart: always
+`.trim();

package/src/utils/ascii.js

@@ -0,0 +1,49 @@
+import figlet from 'figlet';
+import gradient from 'gradient-string';
+import chalk from 'chalk';
+
+export async function showLogo() {
+  try {
+    const text = 'FLOWDEV';
+    const subTitle = "System intelligence & Workflow automation";
+    
+    const data = figlet.textSync(text, {
+      font: 'ANSI Shadow',
+      horizontalLayout: 'full',
+    });
+
+    const colors = [
+      { color: '#fe0000', pos: 0 },   
+      { color: '#f02e20', pos: 0.2 },
+      { color: '#f35322', pos: 0.6 },  
+      { color: '#ff6a00', pos: 1 }     
+    ];
+
+    const flowGradient = gradient(colors);
+
+    const lines = data.split('\n').filter(line => line.trim() !== "");
+    const maxLength = Math.max(...lines.map(l => l.length));
+    
+    const padding = "       "; 
+
+    const b = (char) => chalk.whiteBright.bold(char); 
+
+    console.log(""); 
+
+             
+    console.log(`${padding}${b('┏━')} ${" ".repeat(maxLength - 2)} ${b('━┓')}`);
+
+    lines.forEach(line => {
+      console.log(`${padding}   ${flowGradient(line)}`);
+    });
+
+    console.log(`${padding}   ${chalk.whiteBright.bold(subTitle)}`);
+
+    console.log(`${padding}${b('┗━')} ${" ".repeat(maxLength - 2)} ${b('━┛')}`);
+    
+    console.log(""); 
+
+  } catch (err) {
+    console.log(chalk.red.bold('\n   FLOWDEV'));
+  }
+}

package/src/utils/engine-check.js

@@ -0,0 +1,71 @@
+import ollama from 'ollama';
+import chalk from 'chalk';
+import ora from 'ora';
+import { exec, spawn } from 'node:child_process';
+import { promisify } from 'util';
+import { logger } from './logger.js';
+
+const execAsync = promisify(exec);
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+
+async function waitForOllamaServer({ retries = 15, delayMs = 1000 } = {}) {
+  for (let i = 0; i < retries; i++) {
+    try {
+      await ollama.list();
+      return true;
+    } catch (e) {
+      await sleep(delayMs);
+    }
+  }
+  return false;
+}
+
+async function installOllamaEngine(spinner) {
+  const isWindows = process.platform === 'win32';
+  const installCmd = isWindows
+    ? 'winget install Ollama.Ollama --silent --accept-source-agreements'
+    : 'curl -fsSL https://ollama.com/install.sh | sh';
+
+  
+  spinner.text = chalk.yellow("Installing FlowDev's engine package to run the command... (This may take a while)");
+
+  try {
+    await execAsync(installCmd, { maxBuffer: 10 * 1024 * 1024 });
+    spinner.succeed(chalk.green('FlowDev Engine installed successfully!'));
+    await sleep(1500);
+  } catch (error) {
+    spinner.fail(chalk.red('Automatic installation failed.'));
+    logger.error(`Please install it manually: ${isWindows ? 'winget install Ollama.Ollama' : 'curl -fsSL https://ollama.com/install.sh | sh'}`);
+    throw error;
+  }
+}
+
+export async function ensureEngineReady(spinner, modelName = 'llama3') {
+  
+  try {
+    await execAsync('ollama --version');  
+  } catch (e) {
+    await installOllamaEngine(spinner);
+  }
+  
+  if (!(await waitForOllamaServer({ retries: 3, delayMs: 1000 }))) {
+    spinner.text = chalk.blue('Starting engine in background...');
+    const child = spawn('ollama', ['serve'], { detached: true, stdio: 'ignore' });
+    child.unref();
+    
+    const ready = await waitForOllamaServer({ retries: 30, delayMs: 1000 });
+    if (!ready) throw new Error('Engine server failed to start.');
+  }
+  let hasModel = false;
+  try {
+    const models = await ollama.list();
+    hasModel = Array.isArray(models?.models) && models.models.some((m) => m.name?.startsWith(modelName));
+  } catch (err) { }
+
+  if (!hasModel) {
+    spinner.text = chalk.magenta(`First launch: Downloading AI neurons (${modelName})...`);
+    await ollama.pull({ model: modelName });
+    spinner.succeed(chalk.green('AI brain loaded!'));
+    spinner.start();
+  }
+}

package/src/utils/logger.js

@@ -0,0 +1,23 @@
+import chalk from 'chalk';
+
+export const logger = {
+  info: (msg) => {
+    console.log(`${chalk.blue.bold(' INFO')}    ${msg}`);
+  },
+  
+  success: (msg) => {
+    console.log(`${chalk.green.bold(' SUCCESS')} ${msg}`);
+  },
+  
+  warn: (msg) => {
+    console.log(`${chalk.yellow.bold(' WARN')}    ${msg}`);
+  },
+  
+  error: (msg) => {
+    console.log(`${chalk.red.bold(' ERROR')}   ${msg}`);
+  },
+  
+  log: (msg) => {
+    console.log(msg);
+  }
+};