imlil 1.0.1

package/src/actions/Action.js

@@ -0,0 +1,125 @@
+import glob from 'fast-glob';
+import { promises as fs } from 'fs';
+import esprima from 'esprima';
+import recast from 'recast';
+import simpleGit from 'simple-git';
+import path from 'path';
+import jscodeshift from 'jscodeshift';
+import Parser from 'tree-sitter';
+import JavaScript from 'tree-sitter-javascript';
+
+export default class Action {
+  constructor() {
+    this.git = simpleGit();
+    this.parser = new Parser();
+    this.parser.setLanguage(JavaScript);
+  }
+
+  static async findFiles(pattern) {
+    return glob(pattern);
+  }
+
+  static async readFile(filePath) {
+    return fs.readFile(filePath, 'utf-8');
+  }
+
+  static async writeFile(filePath, content) {
+    if (!filePath) {
+      console.error('Error: filePath is undefined');
+      return;
+    }
+    console.log(`  => Writing file: ${filePath}`);
+    await fs.mkdir(path.dirname(filePath), { recursive: true });
+    const contentToWrite = typeof content === 'string' ? content : JSON.stringify(content, null, 4);
+    await fs.writeFile(filePath, contentToWrite);
+  }
+
+  static async writeTest(filePath, content) {
+    if (!filePath) {
+      console.error('Error: test filePath is undefined');
+      return;
+    }
+    console.log(`  => Writing test: ${filePath}`);
+    await fs.mkdir(path.dirname(filePath), { recursive: true });
+    const contentToWrite = typeof content === 'string' ? content : JSON.stringify(content, null, 4);
+    await fs.writeFile(filePath, contentToWrite);
+  }
+
+  /**
+     * Query a file using Tree-sitter for fast structural analysis.
+     */
+  async queryFile(filePath, queryStr) {
+    const source = await fs.readFile(filePath, 'utf-8');
+    const tree = this.parser.parse(source);
+    const query = new Parser.Query(JavaScript, queryStr);
+    const matches = query.matches(tree.rootNode);
+    return matches;
+  }
+
+  /**
+     * Surgical modification using jscodeshift and recast.
+     */
+  static async modifyFile(filePath, transformCode) {
+    if (!filePath) {
+      console.error('Error: filePath is undefined for modification');
+      return;
+    }
+    console.log(`  => Modifying file: ${filePath}`);
+
+    let source;
+    try {
+      source = await fs.readFile(filePath, 'utf-8');
+    } catch (e) {
+      console.error(`Error reading file ${filePath}:`, e);
+      return;
+    }
+
+    const j = jscodeshift.withParser('tsx');
+    const api = { j, jscodeshift: j, stats: () => {} };
+    const fileInfo = { path: filePath, source };
+
+    try {
+      const result = j.runTransform({ path: filePath, source: fileInfo.source }, transformCode, api, {});
+
+      if (result && typeof result === 'string' && result !== source) {
+        await fs.writeFile(filePath, result);
+        console.log(`  => File modified successfully: ${filePath}`);
+      } else {
+        console.log(`  => No changes applied to: ${filePath}`);
+      }
+    } catch (error) {
+      console.error(`Error executing jscodeshift transform on ${filePath}:`, error);
+    }
+  }
+
+  /**
+     * Specialized action for adding imports or surgical edits using AST.
+     */
+  static async smartEdit(filePath, editInstructions) {
+    // This combines tree-sitter for finding and jscodeshift for editing.
+    // For now, it will be an alias to modifyFile but with a more specialized prompt context.
+    return Action.modifyFile(filePath, editInstructions);
+  }
+
+  static parseCode(code) {
+    return esprima.parseScript(code, { tolerant: true, range: true, loc: true });
+  }
+
+  static modifyCode(code, transformations) {
+    const ast = recast.parse(code);
+    recast.visit(ast, transformations);
+    return recast.print(ast).code;
+  }
+
+  async gitStatus() {
+    return this.git.status();
+  }
+
+  async gitAdd(files) {
+    return this.git.add(files);
+  }
+
+  async gitCommit(message) {
+    return this.git.commit(message);
+  }
+}

package/src/agents/Agent.js

@@ -0,0 +1,64 @@
+class Agent {
+  constructor(name, purpose) {
+    this.id = Agent.generateId();
+    this.name = name;
+    this.purpose = purpose;
+    this.state = 'idle'; // idle, init, working, stopped
+    this.progress = 0;
+    this.result = null;
+    this.error = null;
+    this.intervalId = null;
+  }
+
+  static generateId() {
+    return Math.random().toString(36).substr(2, 9);
+  }
+
+  // Initialize the agent
+  init() {
+    if (this.state !== 'idle') {
+      throw new Error('Agent must be idle to initialize');
+    }
+    this.state = 'init';
+    this.progress = 0;
+    this.result = null;
+    this.error = null;
+  }
+
+  // Start the agent's work
+  start(interval = 1000) {
+    if (this.state !== 'init') {
+      throw new Error('Agent must be initialized to start');
+    }
+    this.state = 'working';
+    this.intervalId = setInterval(() => this.execute(), interval);
+  }
+
+  // Stop the agent
+  stop() {
+    if (this.intervalId) {
+      clearInterval(this.intervalId);
+      this.intervalId = null;
+    }
+    this.state = 'stopped';
+  }
+
+  // Execute the agent's purpose (to be implemented by specific agents)
+  // eslint-disable-next-line class-methods-use-this
+  execute() {
+    throw new Error('Abstract method execute() must be implemented by subclass');
+  }
+
+  // Get the current state of the agent
+  getStatus() {
+    return {
+      name: this.name,
+      state: this.state,
+      progress: this.progress,
+      result: this.result,
+      error: this.error,
+    };
+  }
+}
+
+export default Agent;

package/src/agents/Operator.js

@@ -0,0 +1,147 @@
+import Agent from './Agent.js';
+import callEmbedApi from '../utils/embedapi.js';
+import { getDb } from '../utils/db.js';
+
+class Operator extends Agent {
+  constructor(name, purpose, aiModel, apiKey) {
+    super(name, purpose);
+    this.aiModel = aiModel;
+    this.apiKey = apiKey;
+    this.db = getDb();
+    this.currentTask = null;
+  }
+
+  async generateStructure(objective) {
+    console.log(`Operator designing file structure for: ${objective}`);
+    const structurePrompt = `
+            **CRITICAL: YOUR RESPONSE MUST BE A VALID JSON OBJECT AND NOTHING ELSE.**
+            
+            Based on the objective: "${objective}", design a file structure for the project.
+            Return a JSON object where keys are file paths (relative to root) and values are brief descriptions of content (or null for empty files).
+            Directories are implied by the paths.
+            
+            Example:
+            {
+                "src/index.js": "Entry point",
+                "src/components/Header.js": "Header component",
+                "src/utils/helpers.js": "Helper functions",
+                "package.json": "Project manifest"
+            }
+        `;
+
+    const response = await callEmbedApi(structurePrompt, this.apiKey);
+    try {
+      let parsableJson;
+      if (response.trim().startsWith('{')) {
+        const startIndex = response.indexOf('{');
+        const endIndex = response.lastIndexOf('}');
+        parsableJson = response.substring(startIndex, endIndex + 1);
+      } else {
+        throw new Error('Response is not a JSON object');
+      }
+      return JSON.parse(parsableJson);
+    } catch (error) {
+      console.error('Error parsing structure JSON:', error);
+      return {}; // Fallback to empty if failed
+    }
+  }
+
+  async run(objective) {
+    console.log(`Operator planning for objective: ${objective}`);
+    const planningPrompt = `
+            **CRITICAL: YOUR RESPONSE MUST BE A VALID JSON OBJECT AND NOTHING ELSE.**
+            
+            Generate a project plan for the objective: "${objective}".
+            
+            **ARCHITECTURAL REQUIREMENT: MAXIMUM PARALLELISM**
+            - The goal is to have multiple agents working at the same time.
+            - **Minimize dependencies.** Only use dependencies when strictly necessary.
+            - Break the project into independent components/modules.
+
+            **REQUIRED JSON STRUCTURE:**
+            {
+                "blueprint": {
+                    "fileStructure": "Description of the directory structure (e.g., src/components, src/utils)",
+                    "conventions": "Naming conventions (e.g., PascalCase for components), testing conventions (e.g., place tests in __tests__ folder)",
+                    "techStack": "List of key technologies (e.g., React, Jest, CSS Modules)"
+                },
+                "tasks": [
+                    {
+                        "id": 1, 
+                        "title": "Task Title", 
+                        "description": "Task Description", 
+                        "status": "pending", 
+                        "dependencies": []
+                    }
+                ]
+            }
+        `;
+    const planJson = await callEmbedApi(planningPrompt, this.apiKey);
+    if (planJson) {
+      try {
+        let parsableJson;
+        if (planJson.trim().startsWith('{')) {
+          const startIndex = planJson.indexOf('{');
+          const endIndex = planJson.lastIndexOf('}');
+          parsableJson = planJson.substring(startIndex, endIndex + 1);
+        } else {
+          throw new Error('Response is not a JSON object');
+        }
+
+        const planData = JSON.parse(parsableJson);
+        const { tasks } = planData;
+        const { blueprint } = planData;
+
+        const planId = this.id;
+
+        for (const task of tasks) {
+          await this.db.run(
+            'INSERT INTO tasks (id, title, description, status, dependencies) VALUES (?, ?, ?, ?, ?)',
+            task.id,
+            task.title,
+            task.description,
+            'pending',
+            JSON.stringify(task.dependencies),
+          );
+        }
+
+        console.log(`Plan saved to database with ${tasks.length} tasks.`);
+        return { planId, plan: { tasks, blueprint } };
+      } catch (error) {
+        console.error('Error parsing JSON plan from API:', error);
+        console.error('Received raw API response (expected pure JSON):', planJson);
+        throw error;
+      }
+    }
+    throw new Error('Failed to get a plan from the AI model.');
+  }
+
+  async assignTask(task) {
+    this.currentTask = task;
+    await this.db.run('UPDATE tasks SET status = ? WHERE id = ?', 'assigned', task.id);
+    this.start();
+  }
+
+  async start() {
+    console.log(`Operator ${this.name} starting task: ${this.currentTask.title}`);
+    await this.executeTask();
+    console.log(`Operator ${this.name} finished task: ${this.currentTask.title}`);
+  }
+
+  async executeTask() {
+    if (!this.currentTask) {
+      throw new Error('No task assigned');
+    }
+
+    try {
+      await this.db.run('UPDATE tasks SET status = ? WHERE id = ?', 'running', this.currentTask.id);
+      // AI execution logic will be in the worker
+      await this.db.run('UPDATE tasks SET status = ? WHERE id = ?', 'completed', this.currentTask.id);
+    } catch (error) {
+      await this.db.run('UPDATE tasks SET status = ? WHERE id = ?', 'failed', this.currentTask.id);
+      throw error;
+    }
+  }
+}
+
+export default Operator;

package/src/agents/ScrumAgent.js

@@ -0,0 +1,74 @@
+import Agent from './Agent.js';
+import { getDb } from '../utils/db.js';
+
+class ScrumAgent extends Agent {
+  constructor(name, purpose, aiModel, apiKey, config) {
+    super(name, purpose);
+    this.aiModel = aiModel;
+    this.apiKey = apiKey;
+    this.config = config;
+    this.db = getDb();
+  }
+
+  static async run() {
+    // The ScrumAgent's run loop will be managed by the orchestrator
+  }
+
+  async getNextTask() {
+    const pendingTasks = await this.db.all('SELECT * FROM tasks WHERE status = ?', 'pending');
+    const completedTasks = (await this.db.all('SELECT id FROM tasks WHERE status = ?', 'completed')).map((t) => t.id);
+
+    console.log(`DEBUG: Pending: ${pendingTasks.length}, Completed IDs: ${completedTasks.join(',')}`);
+    console.log(`DEBUG: Current Config: ${JSON.stringify(this.config)}`);
+
+    for (const task of pendingTasks) {
+      let dependencies = [];
+      try {
+        dependencies = JSON.parse(task.dependencies);
+      } catch (e) {
+        console.error(`Error parsing dependencies for task ${task.id}:`, task.dependencies);
+        continue;
+      }
+
+      const areDepsMet = this.config.mode === 'yolo' ? true : dependencies.every((dep) => completedTasks.includes(String(dep)));
+
+      console.log(`DEBUG: Task ${task.id} ("${task.title}") deps: [${dependencies.join(',')}]. Met? ${areDepsMet} (Mode: ${this.config.mode})`);
+
+      if (areDepsMet) {
+        // LOCK IT DOWN: Mark as running immediately to prevent other agents from grabbing it
+        await this.db.run('UPDATE tasks SET status = ? WHERE id = ?', 'running', task.id);
+        return task;
+      }
+    }
+
+    return null;
+  }
+
+  async assignTaskToAgent(task) {
+    await this.db.run('UPDATE tasks SET status = ? WHERE id = ?', 'assigned', task.id);
+  }
+
+  async markTaskAsCompleted(task) {
+    await this.db.run('UPDATE tasks SET status = ? WHERE id = ?', 'completed', task.id);
+  }
+
+  async requeueTask(task) {
+    await this.db.run('UPDATE tasks SET status = ?, retries = retries + 1 WHERE id = ?', 'pending', task.id);
+  }
+
+  async addTask(title, description, dependencies = []) {
+    const id = Date.now().toString() + Math.floor(Math.random() * 1000).toString();
+    await this.db.run(
+      'INSERT INTO tasks (id, title, description, status, dependencies, retries) VALUES (?, ?, ?, ?, ?, ?)',
+      id,
+      title,
+      description,
+      'pending',
+      JSON.stringify(dependencies),
+      0,
+    );
+    return id;
+  }
+}
+
+export default ScrumAgent;

package/src/agents/SupervisorAgent.js

@@ -0,0 +1,198 @@
+import fs from 'fs/promises';
+import path from 'path';
+import Agent from './Agent.js';
+import { getDb } from '../utils/db.js';
+import callEmbedApi from '../utils/embedapi.js';
+
+class SupervisorAgent extends Agent {
+  constructor(name, purpose, aiModel, apiKey, config) {
+    super(name, purpose);
+    this.aiModel = aiModel;
+    this.apiKey = apiKey;
+    this.config = config;
+    this.db = getDb();
+  }
+
+  async run(projectDescription) {
+    console.log('Supervisor initializing...');
+
+    // 1. Setup Environment
+    const imlilDir = path.resolve('.imlil');
+    await fs.mkdir(imlilDir, { recursive: true });
+
+    // 2. Generate Detailed Plan (Markdown)
+    console.log('Phase 1: Generating comprehensive plan...');
+    const dateStr = new Date().toISOString().split('T')[0];
+    const planFilename = `plan-${dateStr}.md`;
+    const planPath = path.join(imlilDir, planFilename);
+
+    const planContent = await this.generatePlan(projectDescription);
+    await fs.writeFile(planPath, planContent);
+    console.log(`  => Plan saved to ${planPath}`);
+
+    // 3. Generate AST (JSON)
+    console.log('Phase 2: Architecting file structure (AST)...');
+    const ast = await this.generateAST(projectDescription, planContent);
+    await fs.writeFile('ast.json', JSON.stringify(ast, null, 2));
+    console.log('  => Project AST saved to ast.json');
+
+    // 4. Generate Tasks (JSON) linked to AST
+    console.log('Phase 3: Deriving actionable tasks...');
+    const tasks = await this.generateTasks(planContent, ast);
+
+    // 5. Populate Database
+    console.log('Phase 4: Populating task database...');
+    // Clear existing pending tasks if any (optional, but good for clean run)
+    // await this.db.run('DELETE FROM tasks');
+
+    for (const task of tasks) {
+      await this.db.run(
+        'INSERT INTO tasks (id, title, description, status, dependencies, retries) VALUES (?, ?, ?, ?, ?, ?)',
+        task.id,
+        task.title,
+        task.description,
+        'pending',
+        JSON.stringify(task.dependencies || []),
+        0,
+      );
+    }
+    console.log(`  => ${tasks.length} tasks queued in database.`);
+
+    // 6. Scaffold (optional but good for visual progress)
+    console.log('Phase 5: Scaffolding empty files...');
+    for (const filePath of Object.keys(ast)) {
+      // Skip if value is null or it looks like a directory but is not needed explicitly
+      const fullPath = path.resolve(filePath);
+      await fs.mkdir(path.dirname(fullPath), { recursive: true });
+      try {
+        await fs.access(fullPath);
+      } catch {
+        // Only write if file doesn't exist
+        if (!filePath.endsWith('/')) {
+          await fs.writeFile(fullPath, '');
+        }
+      }
+    }
+
+    console.log('Plan ready. Execution handed off to Orchestrator.');
+  }
+
+  async callApiWithRetry(prompt, type = 'json', attempt = 1) {
+    const maxRetries = 3;
+    if (attempt > maxRetries) {
+      throw new Error(`Failed to get valid ${type} response after ${maxRetries} attempts.`);
+    }
+
+    try {
+      const response = await callEmbedApi(prompt, this.apiKey);
+
+      if (type === 'markdown') {
+        return response; // No parsing needed
+      }
+
+      // JSON Parsing
+      const cleanJson = (res) => {
+        const startIndex = res.indexOf('{');
+        const endIndex = res.lastIndexOf('}');
+        if (startIndex === -1 || endIndex === -1) {
+          throw new Error('Could not find JSON object in response');
+        }
+        return res.substring(startIndex, endIndex + 1);
+      };
+
+      return JSON.parse(cleanJson(response));
+    } catch (error) {
+      console.error(`Attempt ${attempt} failed: ${error.message}. Retrying...`);
+      const newPrompt = `${prompt}\n\n**PREVIOUS ATTEMPT FAILED!**\nYour last response was not valid. Error: "${error.message}". \nPlease correct your output and strictly follow the format requirements.`;
+      return this.callApiWithRetry(newPrompt, type, attempt + 1);
+    }
+  }
+
+  async generatePlan(description) {
+    const prompt = `
+            You are a Senior Software Architect.
+            Create a comprehensive development plan for the following request: "${description}".
+            
+            **REQUIREMENTS:**
+            1.  **Tech Stack:** Explicitly define the technologies, libraries, and tools to be used. (e.g., React, Tailwind, Express, SQLite). Be specific.
+            2.  **Conventions:** Define coding standards, naming conventions, and file organization rules.
+            3.  **Architecture:** Describe the high-level architecture.
+            4.  **Step-by-Step Plan:** A logical sequence of steps to implement the project.
+
+            **OUTPUT FORMAT:**
+            Return the plan as a clean, well-structured MARKDOWN string.
+        `;
+    return this.callApiWithRetry(prompt, 'markdown');
+  }
+
+  async generateAST(description, planContent) {
+    const prompt = `
+            You are a System Architect.
+            Based on the project plan below, generate a complete JSON Abstract Syntax Tree (AST) representing the file structure of the project.
+            
+            **PLAN:**
+            ${planContent}
+
+            **REQUIREMENTS:**
+            - The JSON keys must be the relative file paths (e.g., "src/index.js", "src/components/Header.js").
+            - The values should be a brief description of the file's purpose.
+            - Include configuration files (package.json, .gitignore, etc.).
+            - Ensure the structure supports the defined tech stack.
+
+            **OUTPUT FORMAT:**
+            A single valid JSON object.
+            Example:
+            {
+                "package.json": "Manifest",
+                "src/index.js": "Entry point"
+            }
+        `;
+    return this.callApiWithRetry(prompt, 'json');
+  }
+
+  async generateTasks(planContent, ast) {
+    const astStr = JSON.stringify(ast, null, 2);
+    const prompt = `
+            You are a Project Manager.
+            Based on the project plan and the file structure (AST), create a list of actionable CRUD tasks to build this project.
+            
+            **PLAN:**
+            ${planContent}
+
+            **FILE STRUCTURE (AST):**
+            ${astStr}
+
+            **REQUIREMENTS:**
+            1.  **Granularity:** Each task should focus on creating or modifying specific files.
+            2.  **CRUD Type:** Tasks must be clear about their action (Create, Read, Update).
+            3.  **Dependencies:** Define task dependencies using IDs.
+            4.  **Order:** Ensure tasks are ordered logically (e.g., setup first, then core logic, then UI).
+            5.  **Parallelism:** Group independent tasks where possible to allow parallel execution by multiple agents.
+
+            **OUTPUT FORMAT:**
+            A single valid JSON object containing an array of "tasks".
+            
+            Required JSON Structure:
+            {
+                "tasks": [
+                    {
+                        "id": 1,
+                        "title": "Initialize Project",
+                        "description": "Create package.json and basic config files.",
+                        "dependencies": []
+                    },
+                    {
+                        "id": 2,
+                        "title": "Create Header Component",
+                        "description": "Implement src/components/Header.js based on the plan.",
+                        "dependencies": [1]
+                    }
+                ]
+            }
+        `;
+    const result = await this.callApiWithRetry(prompt, 'json');
+    return result.tasks;
+  }
+}
+
+export default SupervisorAgent;

package/src/agents/ValidatorAgent.js

@@ -0,0 +1,48 @@
+import { exec } from 'child_process';
+import util from 'util';
+import Agent from './Agent.js';
+
+const execAsync = util.promisify(exec);
+
+class ValidatorAgent extends Agent {
+  constructor(name, purpose, aiModel, apiKey, config) {
+    super(name, purpose);
+    this.aiModel = aiModel;
+    this.apiKey = apiKey;
+    this.config = config;
+  }
+
+  static async validate(task, testPath) {
+    try {
+      if (!testPath) {
+        return { isValid: false, error: 'No test file provided' };
+      }
+
+      if (testPath.endsWith('.js') || testPath.endsWith('.ts') || testPath.endsWith('.jsx') || testPath.endsWith('.tsx')) {
+        // For JS/TS/React, we assume npm test or similar.
+        // For this MVP, we'll try to run the specific test file using node (if it's a standalone script)
+        // or just check if the file exists and has valid syntax if it's a component.
+        // A robust solution would run 'npm test <file>'.
+
+        // Simplified check: Does the file exist?
+        const { stdout } = await execAsync(`ls -l ${testPath}`);
+        return { isValid: true, output: stdout };
+      } if (testPath.endsWith('.c') || testPath.endsWith('.cpp')) {
+        // C/C++ validation
+        // eslint-disable-next-line max-len
+        const { stdout, stderr } = await execAsync(`gcc ${task.filePath || ''} ${testPath} -o test_bin && ./test_bin`);
+        if (stderr) {
+          return { isValid: false, error: stderr };
+        }
+        return { isValid: true, output: stdout };
+      }
+      // Fallback: just check if file exists
+      await execAsync(`ls ${testPath}`);
+      return { isValid: true, output: 'File created' };
+    } catch (error) {
+      return { isValid: false, error: error.message };
+    }
+  }
+}
+
+export default ValidatorAgent;