@flowdevcli/flowdev 1.0.0

package/.dockerignore

@@ -0,0 +1,7 @@
+node_modules
+.git
+.env
+dist
+build
+__pycache__
+*.log

package/.env.example

@@ -0,0 +1,5 @@
+# Auto-generated by FlowDev
+# Environment Variables Example
+
+OLLAMA_MODEL=
+

package/Dockerfile

@@ -0,0 +1,14 @@
+# Stage 1: Build
+FROM node:18-alpine AS builder
+WORKDIR /app
+COPY package*.json ./
+RUN npm ci
+COPY . .
+
+# Stage 2: Production
+FROM node:18-alpine
+WORKDIR /app
+COPY --from=builder /app ./
+EXPOSE 3000
+# Formats the command string into a JSON array for CMD
+CMD ["npm", "run", "dev"]

package/bin/flowdev.js

@@ -0,0 +1,32 @@
+#!/usr/bin/env node
+
+import fs from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+import { showLogo } from '../src/utils/ascii.js'; 
+import { setupCLI } from '../src/core/cli.js';
+
+async function handleBranding() {
+  const ppid = process.ppid;
+  const sessionFlag = path.join(os.tmpdir(), `flowdev_session_${ppid}`);
+
+  if (!fs.existsSync(sessionFlag)) {
+    await showLogo();
+    try {
+      fs.writeFileSync(sessionFlag, '');
+    } catch (e) {
+      
+    }
+  }
+}
+
+async function main() {
+  await handleBranding();
+  const program = setupCLI();
+  program.parse(process.argv);
+}
+
+main().catch((err) => {
+  console.error('\x1b[31m%s\x1b[0m', `Critical error: ${err.message}`);
+  process.exit(1);
+});

package/docker-compose.yml

@@ -0,0 +1,9 @@
+version: '3.8'
+services:
+  flowdev:
+    build: .
+    ports:
+      - "3000:3000"
+    environment:
+      - NODE_ENV=production
+    restart: always

package/k8s.yaml

@@ -0,0 +1,32 @@
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+  name: flowdev
+spec:
+  replicas: 2
+  selector:
+    matchLabels:
+      app: flowdev
+  template:
+    metadata:
+      labels:
+        app: flowdev
+    spec:
+      containers:
+      - name: flowdev
+        image: flowdev:latest 
+        ports:
+        - containerPort: 3000
+---
+apiVersion: v1
+kind: Service
+metadata:
+  name: flowdev-service
+spec:
+  selector:
+    app: flowdev
+  ports:
+    - protocol: TCP
+      port: 80
+      targetPort: 3000
+  type: LoadBalancer

package/package.json

@@ -0,0 +1,51 @@
+{
+  "name": "@flowdevcli/flowdev",
+  "version": "1.0.0",
+  "description": "AI-powered CLI tool",
+  "main": "bin/flowdev.js",
+  "type": "module",
+  "bin": {
+    "flowdev": "/bin/flowdev.js",
+    "fd": "/bin/flowdev.js"
+  },
+  "scripts": {
+    "start": "node bin/flowdev.js",
+    "test": "mocha test/**/*.js",
+    "lint": "eslint src/**/*.js"
+  },
+  "keywords": [
+    "cli",
+    "devtools",
+    "ai",
+    "devops",
+    "scaffold"
+  ],
+  "author": "",
+  "license": "MIT",
+  "dependencies": {
+    "axios": "^1.6.0",
+    "boxen": "^7.1.1",
+    "chalk": "^5.3.0",
+    "commander": "^11.1.0",
+    "dotenv": "^16.3.1",
+    "execa": "^8.0.1",
+    "figlet": "^1.7.0",
+    "fs-extra": "^11.1.1",
+    "gradient-string": "^2.0.2",
+    "inquirer": "^9.2.11",
+    "is-binary-path": "^3.0.0",
+    "mammoth": "^1.11.0",
+    "ollama": "^0.6.3",
+    "ora": "^7.0.1",
+    "pdf-parse": "^2.4.5",
+    "tabtab": "^3.0.2"
+  },
+  "devDependencies": {
+    "eslint": "^8.52.0",
+    "mocha": "^10.2.0"
+  },
+
+  "publishConfig": {
+  "access": "public"
+}
+}

package/src/commands/ai/ask.js

@@ -0,0 +1,178 @@
+import ollama from 'ollama';
+import chalk from 'chalk';
+import ora from 'ora';
+import fs from 'fs-extra';
+import { exec, spawn } from 'node:child_process';
+import { promisify } from 'util';
+import { logger } from '../../utils/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) {
+      
+      logger.debug(`Ollama not ready (attempt ${i + 1}/${retries}): ${e.message}`);
+      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('Downloading FlowDev engine package... (This may take a while)');
+
+  try {
+    
+    const { stdout, stderr } = await execAsync(installCmd, { maxBuffer: 10 * 1024 * 1024 });
+    logger.debug('install stdout: ' + (stdout || '').toString().slice(0, 2000));
+    logger.debug('install stderr: ' + (stderr || '').toString().slice(0, 2000));
+
+    spinner.succeed(chalk.green('FlowDev Engine installed successfully!'));
+    
+    await sleep(1500);
+  } catch (error) {
+    
+    spinner.fail(chalk.red('Automatic installation failed (admin rights or network?)'));
+    logger.error('Automatic installation error: ' + (error.message || error));
+    if (error.stdout || error.stderr) {
+      logger.error('Installer output (truncated):');
+      logger.error((error.stdout || '').toString().slice(0, 500));
+      logger.error((error.stderr || '').toString().slice(0, 500));
+    }
+
+    logger.error(`Try installing it manually: ${isWindows ? 'winget install Ollama.Ollama' : 'curl -fsSL https://ollama.com/install.sh | sh'}`);
+    throw error;
+  }
+}
+
+async function ensureOllamaRunning(spinner) {
+  try {
+   
+    await execAsync('ollama --version');
+  } catch (e) {
+    logger.info('Ollama binary not found. Attempting automatic install...');
+    
+    await installOllamaEngine(spinner);
+  }
+
+  
+  if (await waitForOllamaServer({ retries: 3, delayMs: 1000 })) {
+    return;
+  }
+
+  
+  logger.info('Starting ollama serve in background...');
+  try {
+    
+    const child = spawn('ollama', ['serve'], { detached: true, stdio: 'ignore' });
+    child.unref();
+  } catch (spawnErr) {
+    logger.error('Failed to spawn ollama serve: ' + spawnErr.message);
+    throw spawnErr;
+  }
+
+  
+  const ready = await waitForOllamaServer({ retries: 30, delayMs: 1000 });
+  if (!ready) {
+    throw new Error('Ollama server did not start in time. Check logs or run `ollama serve` manually.');
+  }
+}
+
+export async function askCommand(question) {
+  if (!question) {
+    logger.error('Ask me a question!');
+    return;
+  }
+
+  let spinner = ora(chalk.cyan('Initialization...')).start();
+
+  try {
+    await ensureOllamaRunning(spinner);
+
+  
+    const modelName = process.env.OLLAMA_MODEL || 'llama3';
+
+    let hasModel = false;
+    try {
+      const models = await ollama.list();
+      hasModel = Array.isArray(models?.models) && models.models.some((m) => m.name?.startsWith(modelName));
+    } catch (err) {
+      logger.debug('Error listing models: ' + (err?.message || err));
+   
+    }
+
+    if (!hasModel) {
+      spinner.text = chalk.magenta('First launch: Configuring neurons...');
+      spinner.start();
+
+      try {
+        await ollama.pull({ model: modelName });
+        spinner.succeed(chalk.green('AI brain in charge !'));
+      } catch (pullErr) {
+        spinner.fail(chalk.red('Failed to download model.'));
+        logger.error('ollama.pull error: ' + (pullErr?.message || pullErr));
+        throw pullErr;
+      }
+
+      
+      spinner = ora(chalk.cyan('Thinking...')).start();
+    } else {
+      spinner.text = chalk.cyan('Thinking...');
+    }
+
+    
+    let context = 'flowdev intelligent CLI tool';
+    try {
+      if (await fs.pathExists('package.json')) {
+        const pkg = await fs.readJson('package.json');
+        if (pkg?.name) context += ` CURRENT CONTEXT: The user is in the project folder "${pkg.name}".`;
+      }
+    } catch (e) {
+      logger.debug('Failed to read package.json: ' + (e?.message || e));
+    }
+
+    const response = await ollama.chat({
+      model: modelName,
+      messages: [
+        { role: 'system', content: context },
+        { role: 'user', content: question },
+      ],
+      stream: true,
+    });
+
+    
+    spinner.stop();
+
+    for await (const part of response) {
+      const content = part?.message?.content;
+      if (typeof content === 'string') {
+        process.stdout.write(chalk.white(content));
+      }
+    }
+
+    process.stdout.write('\n');
+  } catch (error) {
+    
+    try { spinner.stop(); } catch (_) {}
+
+    logger.error('askCommand error: ' + (error?.message || error));
+
+    if (error?.code === 'ENOENT') {
+      console.log(chalk.red('\nUnable to find or install Ollama automatically.'));
+    } else {
+      console.log(chalk.red(`\nError: ${error?.message || error}`));
+    }
+  }
+}

package/src/commands/ai/audit.js

@@ -0,0 +1,78 @@
+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';
+
+const AUDIT_EXTENSIONS = ['.js', '.ts', '.py', '.php', '.go', '.jsx', '.tsx', '.vue'];
+const IGNORE_DIRS = ['node_modules', '.git', 'dist', 'build', 'venv'];
+
+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 [];
+    return (await fs.stat(res)).isDirectory() ? getFiles(res) : res;
+  }));
+  return files.flat().filter(f => AUDIT_EXTENSIONS.includes(path.extname(f)));
+}
+
+export async function auditCommand() {
+  const spinner = ora(chalk.cyan('Scanning project for audit...')).start();
+
+  try {
+    const rootDir = process.cwd();
+    const files = await getFiles(rootDir);
+
+    if (files.length === 0) {
+      spinner.fail(chalk.red('No source files found to audit.'));
+      return;
+    }
+
+    await ensureEngineReady(spinner, 'llama3');
+    
+    spinner.text = chalk.magenta(`Auditing ${files.length} files...`);
+
+    let codeContext = "";
+    for (const file of files.slice(0, 10)) { 
+        const content = await fs.readFile(file, 'utf-8');
+        codeContext += `\n--- File: ${path.basename(file)} ---\n${content}\n`;
+    }
+
+    const prompt = `
+      As an Expert Security Auditor,
+      Analyze the following code for:
+      1. Potential Bugs or logic errors.
+      2. Security vulnerabilities (exposed keys, unsafe inputs).
+      3. Performance bottlenecks.
+      4. Code quality and Best Practices.
+
+      Provide a concise report with clear headings and bullet points.
+      If the code is perfect, congratulate the developer.
+      
+      Code to analyze:
+      ${codeContext}
+    `;
+
+    const response = await ollama.chat({
+      model: 'llama3',
+      messages: [{ role: 'user', content: prompt }],
+      stream: true,
+    });
+
+    spinner.stop();
+    console.log(chalk.bold.yellow('\n FLOWDEV AUDIT REPORT\n'));
+
+    for await (const part of response) {
+      process.stdout.write(chalk.white(part.message.content));
+    }
+
+    console.log(chalk.cyan('\n\nAudit complete. Always double-check AI suggestions before applying.'));
+
+  } catch (error) {
+    spinner.stop();
+    logger.error(`Audit failed: ${error.message}`);
+  }
+}

package/src/commands/ai/explain.js

@@ -0,0 +1,66 @@
+import ollama from 'ollama';
+import chalk from 'chalk';
+import ora from 'ora';
+import fs from 'fs-extra';
+import path from 'path';
+import isBinaryPath from 'is-binary-path';
+import { createRequire } from 'module';
+import { ensureEngineReady } from '../../utils/engine-check.js';
+import { logger } from '../../utils/logger.js';
+
+const require = createRequire(import.meta.url);
+const pdf = require('pdf-parse');
+const mammoth = require('mammoth');
+                                                    
+async function extractText(filePath) { 
+  const ext = path.extname(filePath).toLowerCase();     
+  if (ext === '.docx') {
+    const buffer = await fs.readFile(filePath); 
+    const result = await mammoth.extractRawText({ buffer });
+    return result.value;
+  }
+  if (ext === '.pdf') {
+    const buffer = await fs.readFile(filePath);
+    const data = await pdf(buffer);
+    return data.text;
+  }
+  if (isBinaryPath(filePath)) throw new Error('Binary files are not supported.');
+  
+  return await fs.readFile(filePath, 'utf-8');
+}
+
+export async function explainCommand(filePath) {
+  if (!filePath) {
+    logger.error('Please specify a file path.'); 
+    return;   
+  }
+
+  const spinner = ora(chalk.cyan('Initializing...')).start();
+
+  try {
+    await ensureEngineReady(spinner, 'llama3');
+
+    spinner.text = chalk.cyan(`Reading ${path.basename(filePath)}...`); 
+    const content = await extractText(filePath);
+
+    spinner.text = chalk.magenta('Analyzing content...');
+    const response = await ollama.chat({  
+      model: 'llama3',
+      messages: [{ 
+        role: 'user', 
+        content: `Explain the following content clearly and concisely:\n\n${content.substring(0, 15000)}` 
+      }],
+      stream: true,
+    });
+
+    spinner.stop(); 
+    console.log(chalk.red.bold(`ANALYSIS: ${path.basename(filePath).toUpperCase()} `));
+    
+    for await (const part of response) {
+      process.stdout.write(chalk.white(part.message.content));
+    }
+  } catch (error) {
+    spinner.stop();
+    logger.error(`Explain error: ${error.message}`);
+  }
+}

package/src/commands/ai/test.js

@@ -0,0 +1,73 @@
+import ollama from 'ollama';
+import chalk from 'chalk';
+import ora from 'ora';
+import fs from 'fs-extra';
+import path from 'path';
+import { logger } from '../../utils/logger.js';
+import { ensureEngineReady } from '../../utils/engine-check.js'; 
+
+export async function testCommand(fileRelativePath) {
+  const spinner = ora(chalk.cyan(`Preparing test generation...`)).start();
+
+  try {
+    const filePath = path.resolve(process.cwd(), fileRelativePath);
+    
+    
+    if (!(await fs.pathExists(filePath))) {
+      spinner.fail(chalk.red(`File not found: ${fileRelativePath}`));
+      return;
+    }
+
+    
+    await ensureEngineReady(spinner, 'llama3');
+
+    const content = await fs.readFile(filePath, 'utf-8');
+    const ext = path.extname(filePath);
+    const fileName = path.basename(filePath, ext);
+    const dir = path.dirname(filePath);
+    
+    let framework = "Vitest";
+    let testFileName = `${fileName}.test${ext}`;
+    
+    if (ext === '.py') {
+      framework = "Pytest";
+      testFileName = `test_${fileName}${ext}`;
+    }
+
+    spinner.text = chalk.magenta(`Writing ${framework} tests for ${fileName}...`);
+
+    const prompt = `
+      Analyze the following code and generate a complete test file using ${framework}.
+      Requirements:
+      - Include all necessary imports.
+      - Cover the main functions with "happy path" and "edge cases" (extremes, nulls, errors).
+      - Use descriptive test names.
+      - Return ONLY the code block starting with \`\`\` and ending with \`\`\`.
+      
+      Code to test:
+      ${content}
+    `;
+
+    const response = await ollama.chat({
+      model: 'llama3',
+      messages: [{ role: 'user', content: prompt }],
+    });
+
+    const fullResponse = response.message.content;
+    
+    const codeBlockRegex = /```[\w]*\n([\s\S]*?)```/;
+    const match = fullResponse.match(codeBlockRegex);
+    const testCode = match ? match[1] : fullResponse;
+
+    const outputPath = path.join(dir, testFileName);
+    await fs.writeFile(outputPath, testCode);
+
+    (chalk.green(`Tests generated successfully!`));
+    console.log(chalk.gray(`\n Location: `) + chalk.white(outputPath));
+    console.log(chalk.yellow(` Tip: Run your tests with '${ext === '.py' ? 'pytest' : 'npm test'}'`));
+
+  } catch (error) {
+    (chalk.red('Test generation failed.'));
+    logger.error(error.message);
+  }
+}

package/src/commands/devops/dockerize.js

@@ -0,0 +1,90 @@
+import fs from 'fs-extra';
+import path from 'node:path';
+import inquirer from 'inquirer';
+import ora from 'ora';
+import chalk from 'chalk';
+import { nodeDockerfile, pythonDockerfile, dockerCompose } from '../../templates/docker/templates.js';
+
+export async function dockerizeCommand() {
+  const cwd = process.cwd();
+  const projectName = path.basename(cwd); 
+
+  let detectedType = 'unknown';
+  if (await fs.pathExists(path.join(cwd, 'package.json'))) detectedType = 'node';
+  else if (await fs.pathExists(path.join(cwd, 'requirements.txt'))) detectedType = 'python';
+
+  console.log(chalk.bold(`\n Dockerizing ${chalk.cyan(projectName)}`));
+  if (detectedType !== 'unknown') {
+    console.log(chalk.gray(`Detected type: ${detectedType.toUpperCase()}`));
+  }
+
+  const answers = await inquirer.prompt([
+    {
+      type: 'list',
+      name: 'type',
+      message: 'What is your application type?',
+      choices: ['Node.js', 'Python', 'Other'],
+      default: detectedType === 'node' ? 'Node.js' : (detectedType === 'python' ? 'Python' : 'Other')
+    },
+    {
+      type: 'input',
+      name: 'port',
+      message: 'Which port is your app listening on?',
+      default: '3000',
+      validate: (input) => !isNaN(input) || 'Please enter a number.'
+    },
+    {
+      type: 'input',
+      name: 'version',
+      message: 'Which language version (Docker tag)?',
+      default: (answers) => answers.type === 'Node.js' ? '18' : '3.11'
+    },
+   
+    {
+      type: 'input',
+      name: 'startCommand',
+      message: 'Start command (e.g., npm run dev):',
+      default: 'npm start',
+      when: (answers) => answers.type === 'Node.js'
+    },
+    
+    {
+      type: 'input',
+      name: 'startFile',
+      message: 'Main entry file (e.g., app.py, main.py):',
+      default: 'app.py',
+      when: (answers) => answers.type === 'Python'
+    }
+  ]);
+
+  const spinner = ora('Generating containers...').start();
+
+  try {
+    let dockerfileContent = '';
+
+    
+    if (answers.type === 'Node.js') {
+      dockerfileContent = nodeDockerfile(answers.version, answers.port, answers.startCommand);
+    } else if (answers.type === 'Python') {
+      dockerfileContent = pythonDockerfile(answers.version, answers.port, answers.startFile);
+    } else {
+      dockerfileContent = '# Generic template\nFROM alpine:latest\nCMD ["echo", "Hello World"]';
+    }
+
+    await fs.writeFile(path.join(cwd, 'Dockerfile'), dockerfileContent.trim());
+    const composeContent = dockerCompose(projectName.toLowerCase().replace(/[^a-z0-9]/g, '-'), answers.port);
+    await fs.writeFile(path.join(cwd, 'docker-compose.yml'), composeContent.trim());
+    
+    const ignoreContent = 'node_modules\n.git\n.env\ndist\nbuild\n__pycache__\n*.log';
+    await fs.writeFile(path.join(cwd, '.dockerignore'), ignoreContent);
+
+    spinner.succeed(chalk.green('Dockerfiles generated successfully!'));
+    
+    console.log('\nTo start your project:');
+    console.log(chalk.blue(`  docker-compose up --build`));
+
+  } catch (error) {
+    spinner.fail(chalk.red('Error during generation.'));
+    console.error(error);
+  }
+}