lwazi-2.0 0.1.0

package/bin/lwazi.js

@@ -0,0 +1,336 @@
+#!/usr/bin/env node
+
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import { createRequire } from 'module';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const require = createRequire(import.meta.url);
+const cliRoot = path.resolve(__dirname, '..');
+const projectRoot = process.cwd();
+
+async function main() {
+  const args = process.argv.slice(2);
+  const command = args[0] || 'help';
+
+  switch (command) {
+    case 'init':
+      await initCommand();
+      break;
+    case 'sync':
+      await syncCommand();
+      break;
+    case 'inspect':
+      await inspectCommand(args);
+      break;
+    case 'status':
+      await statusCommand();
+      break;
+    case 'start':
+      await startCommand();
+      break;
+    case 'link':
+      await linkCommand();
+      break;
+    case 'ask':
+      await askCommand(args.slice(1));
+      break;
+    case 'help':
+    case '--help':
+    case '-h':
+      showHelp();
+      break;
+    case 'version':
+    case '--version':
+    case '-v':
+      showVersion();
+      break;
+    default:
+      console.error(`Unknown command: ${command}`);
+      showHelp();
+      process.exit(1);
+  }
+}
+
+async function initCommand() {
+  const { Init } = await import('../lib/init.js');
+  const init = new Init(projectRoot);
+  await init.run();
+}
+
+async function syncCommand() {
+  const configPath = path.join(projectRoot, 'lwazi.config.json');
+  if (!fs.existsSync(configPath)) {
+    console.error('No lwazi.config.json found. Run "lwazi-2.0 init" first.');
+    process.exit(1);
+  }
+
+  const { Sync } = await import('../lib/sync.js');
+  const sync = new Sync(projectRoot);
+  await sync.sync();
+}
+
+async function inspectCommand(args) {
+  const configPath = path.join(projectRoot, 'lwazi.config.json');
+  if (!fs.existsSync(configPath)) {
+    console.error('No lwazi.config.json found. Run "lwazi-2.0 init" first.');
+    process.exit(1);
+  }
+
+  const config = JSON.parse(fs.readFileSync(configPath, 'utf-8'));
+  const serverUrl = config.lwazi_server || 'http://localhost:11500';
+
+  const addUrlIndex = args.indexOf('--add-url');
+  if (addUrlIndex !== -1 && args[addUrlIndex + 1]) {
+    console.log('Manual URL addition not yet implemented via CLI.');
+    console.log('Edit the lwazi.config.json or re-index with updated routes.');
+    return;
+  }
+
+  try {
+    const axios = (await import('axios')).default;
+    const response = await axios.get(`${serverUrl}/health`);
+    const health = response.data;
+
+    console.log('\n' + '='.repeat(60));
+    console.log('  Lwazi Project Inspection');
+    console.log('='.repeat(60));
+    console.log(`\n  Project:       ${config.project_name}`);
+    console.log(`  Project ID:    ${config.project_id}`);
+    console.log(`  Base URL:      ${config.base_url}`);
+    console.log(`  Server:        ${config.lwazi_server}`);
+    console.log(`  Indexed:       ${config.last_synced || 'Not yet synced'}`);
+    console.log(`  LLM Model:     ${health.llm?.model || 'unknown'}`);
+    console.log(`  Embedding:     ${health.llm?.embedding_model || 'unknown'}`);
+    console.log(`\n  Skip paths:    ${config.skip_paths?.join(', ') || 'none'}`);
+    console.log(`  Max crawl:     ${config.max_crawl_pages} pages`);
+    console.log('='.repeat(60) + '\n');
+  } catch (err) {
+    console.log('\n  Project config (server offline):');
+    console.log(`  Project:       ${config.project_name}`);
+    console.log(`  Project ID:    ${config.project_id}`);
+    console.log(`  Base URL:      ${config.base_url}`);
+    console.log(`  Server:        ${config.lwazi_server}\n`);
+  }
+}
+
+async function statusCommand() {
+  const configPath = path.join(projectRoot, 'lwazi.config.json');
+  const config = fs.existsSync(configPath) ? JSON.parse(fs.readFileSync(configPath, 'utf-8')) : null;
+  const serverUrl = config?.lwazi_server || 'http://localhost:11500';
+
+  console.log('\n' + '='.repeat(60));
+  console.log('  Lwazi Status');
+  console.log('='.repeat(60));
+
+  try {
+    const axios = (await import('axios')).default;
+    const health = await axios.get(`${serverUrl}/health`, { timeout: 5000 });
+    const h = health.data;
+
+    console.log(`\n  Server:        ${h.status === 'ok' ? '✓ Running' : '✗ Degraded'}`);
+    console.log(`  LLM:           ${h.llm?.model || 'Not available'}`);
+    console.log(`  Embedding:     ${h.llm?.embedding_model || 'Not available'}`);
+    console.log(`  Response time: ${h.response_time_ms}ms`);
+
+    if (config) {
+      console.log(`\n  Project:       ${config.project_name}`);
+      console.log(`  Last indexed:  ${config.last_synced || 'Never'}`);
+      console.log(`  Routes URL:    ${config.base_url}`);
+    } else {
+      console.log(`\n  Project:       Not initialized (no lwazi.config.json)`);
+    }
+  } catch (err) {
+    console.log(`\n  Server:        ✗ Offline (${err.code || err.message})`);
+    console.log(`  Expected at:   ${serverUrl}`);
+
+    if (config) {
+      console.log(`\n  Project config found: ${config.project_name}`);
+      console.log(`  Run "lwazi-2.0 start" to start the server.`);
+    }
+  }
+
+  console.log('='.repeat(60) + '\n');
+}
+
+async function startCommand() {
+  console.log('\n  Starting Lwazi Server...\n');
+
+  try {
+    const axios = (await import('axios')).default;
+    const ollamaCheck = await axios.get('http://localhost:11434/api/tags', { timeout: 5000 });
+    const models = ollamaCheck.data?.models || [];
+    const modelNames = models.map(m => m.name);
+
+    console.log(`  Ollama:        ✓ Running`);
+    console.log(`  Models:        ${modelNames.join(', ') || 'none'}`);
+
+    if (!modelNames.some(m => m.includes('llama3.2'))) {
+      console.log(`\n  ⚠  Recommended model "llama3.2:1b" not found.`);
+      console.log('  Pull it with: ollama pull llama3.2:1b');
+    }
+  } catch (err) {
+    console.log('  Ollama:        ✗ Not running');
+    console.log('  Start Ollama:  ollama serve');
+    process.exit(1);
+  }
+
+  const serverDir = path.resolve(cliRoot, '..', 'server');
+  if (!fs.existsSync(path.join(serverDir, 'main.py'))) {
+    console.error('  Server files not found at', serverDir);
+    process.exit(1);
+  }
+
+  const venvPython = path.join(serverDir, 'venv', 'bin', 'python3');
+  const venvPythonWin = path.join(serverDir, 'venv', 'Scripts', 'python.exe');
+  let pythonCmd = 'python3';
+  if (fs.existsSync(venvPython)) {
+    pythonCmd = venvPython;
+    console.log(`  Using venv:    server/venv/`);
+  } else if (fs.existsSync(venvPythonWin)) {
+    pythonCmd = venvPythonWin;
+    console.log(`  Using venv:    server/venv/`);
+  } else {
+    console.log('  ⚠  No venv found. Create one with:');
+    console.log('       cd server && python3 -m venv venv && source venv/bin/activate && pip install -r requirements.txt\n');
+  }
+
+  const port = process.env.LWAZI_PORT || 11500;
+  console.log(`  Starting server on port ${port}...\n`);
+
+  const { spawn } = await import('child_process');
+  const server = spawn(pythonCmd, ['-m', 'uvicorn', 'server.main:app', '--host', '0.0.0.0', '--port', String(port), '--reload'], {
+    cwd: serverDir,
+    stdio: 'inherit',
+    env: { ...process.env, LWAZI_PORT: String(port) }
+  });
+
+  process.on('SIGINT', () => {
+    server.kill('SIGINT');
+    process.exit(0);
+  });
+
+  process.on('SIGTERM', () => {
+    server.kill('SIGTERM');
+    process.exit(0);
+  });
+}
+
+async function linkCommand() {
+  const { execSync } = await import('child_process');
+  try {
+    console.log('\n  Linking Lwazi CLI globally...\n');
+    execSync('npm link', { cwd: cliRoot, stdio: 'inherit' });
+    console.log('\n  Done! You can now run "lwazi-2.0" from any project.\n');
+  } catch (err) {
+    console.error('  Link failed. Try: cd cli && npm link');
+    process.exit(1);
+  }
+}
+
+async function askCommand(args) {
+  const question = args.join(' ');
+  if (!question) {
+    console.error('Usage: lwazi-2.0 ask "your question here"');
+    process.exit(1);
+  }
+
+  const configPath = path.join(projectRoot, 'lwazi.config.json');
+  if (!fs.existsSync(configPath)) {
+    console.error('No lwazi.config.json found. Run "lwazi-2.0 init" first.');
+    process.exit(1);
+  }
+
+  const config = JSON.parse(fs.readFileSync(configPath, 'utf-8'));
+  const serverUrl = config.lwazi_server || 'http://localhost:11500';
+
+  console.log(`\n  Asking Lwazi: "${question}"\n`);
+
+  try {
+    const axios = (await import('axios')).default;
+    const response = await axios.post(`${serverUrl}/chat`, {
+      project_id: config.project_id,
+      message: question,
+      session_id: null
+    }, { timeout: 120000 });
+
+    const data = response.data;
+
+    if (data.type === 'answer') {
+      console.log(`  ${data.message}\n`);
+      if (data.sources && data.sources.length > 0) {
+        console.log('  Sources:');
+        for (const src of data.sources) {
+          console.log(`    • ${src.title}: ${src.url}`);
+        }
+      }
+      if (data.answer_confidence === 'low') {
+        console.log('\n  ⚠  I\'m not fully certain — please verify.');
+      }
+    } else if (data.type === 'auth_required') {
+      console.log(`  🔒 ${data.message}`);
+    } else if (data.type === 'not_found') {
+      console.log(`  ${data.message}`);
+    } else if (data.type === 'error') {
+      console.log(`  ✗ ${data.message}`);
+    }
+
+    console.log('');
+  } catch (err) {
+    if (err.code === 'ECONNREFUSED') {
+      console.error('  Error: Lwazi server is not running.');
+      console.error(`  Start it with: lwazi-2.0 start`);
+    } else {
+      console.error('  Error:', err.message);
+    }
+  }
+}
+
+function showHelp() {
+  console.log(`
+  Lwazi 2.0 — Intelligent project-aware AI chatbot
+
+  USAGE:
+    lwazi-2.0 <command>
+
+  COMMANDS:
+    init        Install Lwazi into the current project
+    sync        Re-index the project (after changes)
+    inspect     Show project configuration and indexing details
+    status      Check server health and project status
+    start       Start the Lwazi server
+    ask         Ask a question from the terminal
+    help        Show this help message
+    version     Show version information
+
+  EXAMPLES:
+    lwazi-2.0 init
+    lwazi-2.0 ask "how do I register?"
+    lwazi-2.0 inspect --add-url "/pricing" "Pricing Page"
+  `);
+}
+
+function showVersion() {
+  const pkgPath = path.join(cliRoot, 'package.json');
+  if (fs.existsSync(pkgPath)) {
+    const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'));
+    console.log(`lwazi-2.0 v${pkg.version}`);
+  } else {
+    console.log('lwazi-2.0 v0.1.0');
+  }
+}
+
+main().catch(err => {
+  if (err.code === 'ERR_MODULE_NOT_FOUND' || err.code === 'MODULE_NOT_FOUND') {
+    console.error('\n  Lwazi CLI is not installed.\n');
+    console.error('  Run these commands to set it up:');
+    console.error(`    cd ${path.resolve(__dirname, '..')}`);
+    console.error('    npm install');
+    console.error('    npm link\n');
+    console.error('  Then run your command again.\n');
+  } else {
+    console.error('Fatal error:', err.message);
+  }
+  process.exit(1);
+});

package/lib/init.js

@@ -0,0 +1,216 @@
+import fs from 'fs';
+import path from 'path';
+import { createRequire } from 'module';
+import inquirer from 'inquirer';
+import chalk from 'chalk';
+
+const require = createRequire(import.meta.url);
+const { nanoid } = await import('nanoid');
+
+import { ProjectProbe } from './project_probe.js';
+import { InjectWidget } from './inject_widget.js';
+
+export class Init {
+  constructor(projectRoot) {
+    this.projectRoot = path.resolve(projectRoot);
+    this.configPath = path.join(this.projectRoot, 'lwazi.config.json');
+  }
+
+  async run() {
+    console.log(chalk.bold('\n  Lwazi 2.0 — Install into project\n'));
+
+    const probe = new ProjectProbe(this.projectRoot);
+    const probeResult = probe.probe();
+    probe.display(probeResult);
+
+    if (fs.existsSync(this.configPath)) {
+      const existing = JSON.parse(fs.readFileSync(this.configPath, 'utf-8'));
+      console.log(chalk.yellow(`  Existing config found for project: ${existing.project_name}`));
+      const { overwrite } = await inquirer.prompt([{
+        type: 'confirm',
+        name: 'overwrite',
+        message: 'Re-initialize this project?',
+        default: false
+      }]);
+      if (!overwrite) {
+        console.log('  Init cancelled.');
+        return;
+      }
+    }
+
+    const defaultName = path.basename(this.projectRoot);
+
+    const answers = await inquirer.prompt([
+      {
+        type: 'input',
+        name: 'projectName',
+        message: 'Project name?',
+        default: defaultName
+      },
+      {
+        type: 'input',
+        name: 'baseUrl',
+        message: 'What URL does this site run on locally?',
+        default: 'http://localhost:3000'
+      },
+      {
+        type: 'input',
+        name: 'lwaziServer',
+        message: 'Lwazi server URL?',
+        default: 'http://localhost:11500'
+      },
+      {
+        type: 'input',
+        name: 'skipDirs',
+        message: 'Any directories to skip during indexing? (comma-separated, or Enter to skip)',
+        default: ''
+      },
+      {
+        type: 'confirm',
+        name: 'setUserPassword',
+        message: 'Set a user-level password? (for protected content)',
+        default: false
+      },
+      {
+        type: 'password',
+        name: 'userPassword',
+        message: 'User password:',
+        when: (a) => a.setUserPassword,
+        mask: '*'
+      },
+      {
+        type: 'confirm',
+        name: 'setAdminPassword',
+        message: 'Set an admin password?',
+        default: false
+      },
+      {
+        type: 'password',
+        name: 'adminPassword',
+        message: 'Admin password:',
+        when: (a) => a.setAdminPassword,
+        mask: '*'
+      }
+    ]);
+
+    const projectId = nanoid(12);
+    const skipPaths = answers.skipDirs ? answers.skipDirs.split(',').map(s => s.trim()).filter(Boolean) : [];
+
+    const config = {
+      project_id: projectId,
+      project_name: answers.projectName,
+      project_root: this.projectRoot,
+      base_url: answers.baseUrl.replace(/\/+$/, ''),
+      lwazi_server: answers.lwaziServer.replace(/\/+$/, ''),
+      skip_paths: skipPaths,
+      max_crawl_pages: 500,
+      created_at: new Date().toISOString(),
+      last_synced: null,
+    };
+
+    if (answers.setUserPassword && answers.userPassword) {
+      const bcryptjs = await import('bcryptjs');
+      config.user_password_hash = bcryptjs.hashSync(answers.userPassword, 10);
+    }
+
+    if (answers.setAdminPassword && answers.adminPassword) {
+      const bcryptjs = await import('bcryptjs');
+      config.admin_password_hash = bcryptjs.hashSync(answers.adminPassword, 10);
+    }
+
+    fs.writeFileSync(this.configPath, JSON.stringify(config, null, 2));
+    console.log(chalk.green(`\n  ✓ Config written to lwazi.config.json`));
+
+    const serverUrl = answers.lwaziServer.replace(/\/+$/, '');
+
+    console.log(chalk.bold(`\n  Indexing project...\n`));
+
+    const axios = (await import('axios')).default;
+
+    try {
+      const response = await axios.post(`${serverUrl}/index`, {
+        project_id: projectId,
+        project_root: this.projectRoot,
+        base_url: config.base_url,
+        project_name: answers.projectName,
+        max_crawl_pages: 500,
+        skip_paths: skipPaths
+      }, {
+        responseType: 'stream',
+        timeout: 600000
+      });
+
+      const stream = response.data;
+      let resultData = '';
+
+      for await (const chunk of stream) {
+        const text = chunk.toString();
+        const lines = text.split('\n').filter(l => l.trim());
+
+        for (const line of lines) {
+          if (line.startsWith('data:')) {
+            const data = line.slice(5).trim();
+            if (data === '[DONE]') break;
+            try {
+              const parsed = JSON.parse(data);
+              if (parsed.event === 'progress') {
+                process.stdout.write(`\r  ${chalk.cyan(parsed.data)}`);
+              } else if (parsed.event === 'complete') {
+                resultData = parsed.data;
+              } else if (parsed.event === 'error') {
+                console.log(`\n  ${chalk.red('Error:')} ${parsed.data}`);
+              }
+            } catch (e) {
+              if (data && !data.startsWith('[')) {
+                process.stdout.write(`\r  ${chalk.cyan(data)}`);
+              }
+            }
+          }
+        }
+      }
+
+      console.log('\n');
+
+      if (resultData) {
+        try {
+          const result = JSON.parse(resultData);
+          console.log(chalk.green('  ✓ Indexing complete!'));
+          console.log(`    Files indexed: ${result.files_indexed}`);
+          console.log(`    Routes found:  ${result.routes_found}`);
+          console.log(`    Pages crawled: ${result.pages_indexed}`);
+          console.log(`    Framework:     ${result.framework_detected}`);
+          console.log(`    Duration:      ${result.duration_seconds}s`);
+        } catch (e) {
+          console.log('  Indexing completed.');
+        }
+      }
+    } catch (err) {
+      if (err.code === 'ECONNREFUSED') {
+        console.log(chalk.yellow('  ⚠  Could not reach Lwazi server. Config saved, but indexing was skipped.'));
+        console.log(chalk.yellow('     Start the server with: lwazi-2.0 start'));
+        console.log(chalk.yellow('     Then run:              lwazi-2.0 sync'));
+      } else {
+        console.log(chalk.yellow(`  ⚠  Indexing encountered an issue: ${err.message}`));
+        console.log(chalk.yellow('     Config was saved. Run "lwazi-2.0 sync" to try again.'));
+      }
+    }
+
+    console.log(chalk.bold('\n  Injecting chat widget...\n'));
+    const injector = new InjectWidget(this.projectRoot, serverUrl, projectId);
+    const injectResult = await injector.inject();
+    injector.report();
+
+    if (injectResult.injected.length > 0) {
+      console.log(chalk.green('  ✓ Lwazi is ready!'));
+    } else {
+      console.log(chalk.yellow('  ⚠  Manual widget injection needed.'));
+    }
+
+    console.log(chalk.bold('\n  Next steps:'));
+    console.log('    - Browse your site and look for the chat bubble');
+    console.log('    - Run: lwazi-2.0 status    (check server health)');
+    console.log('    - Run: lwazi-2.0 inspect   (verify routes)');
+    console.log('    - Run: lwazi-2.0 ask "question"  (test from terminal)');
+    console.log('    - Run: lwazi-2.0 sync      (re-index after changes)\n');
+  }
+}

package/lib/inject_widget.js

@@ -0,0 +1,179 @@
+import fs from 'fs';
+import path from 'path';
+import { glob } from 'glob';
+
+export class InjectWidget {
+  constructor(projectRoot, lwaziServer, projectId) {
+    this.projectRoot = path.resolve(projectRoot);
+    this.lwaziServer = lwaziServer.replace(/\/+$/, '');
+    this.projectId = projectId;
+    this.injected = [];
+    this.failed = [];
+  }
+
+  async inject() {
+    const injectionPoints = await this.findInjectionPoints();
+
+    if (injectionPoints.length === 0) {
+      this.createLoaderFile();
+      return { injected: [], failed: [], loaderCreated: true };
+    }
+
+    const scriptTag = `<script src="${this.lwaziServer}/widget/lwazi-widget.js" data-project-id="${this.projectId}" data-server="${this.lwaziServer}" defer></script>`;
+
+    for (const filePath of injectionPoints) {
+      try {
+        let content = fs.readFileSync(filePath, 'utf-8');
+        const bodyCloseIndex = content.lastIndexOf('</body>');
+        if (bodyCloseIndex !== -1) {
+          content = content.slice(0, bodyCloseIndex) + '  ' + scriptTag + '\n' + content.slice(bodyCloseIndex);
+        } else {
+          content += '\n' + scriptTag + '\n';
+        }
+        fs.writeFileSync(filePath, content, 'utf-8');
+        this.injected.push(filePath);
+      } catch (err) {
+        this.failed.push({ file: filePath, error: err.message });
+      }
+    }
+
+    return { injected: this.injected, failed: this.failed, loaderCreated: false };
+  }
+
+  async findInjectionPoints() {
+    const points = new Set();
+
+    const knownLayouts = [
+      'app/layout.tsx', 'app/layout.jsx', 'app/layout.js',
+      'pages/_app.js', 'pages/_app.tsx', 'pages/_app.jsx', 'pages/_app.ts',
+      'resources/views/layouts/app.blade.php',
+      'resources/views/layouts/master.blade.php',
+      'templates/base.html', 'templates/layout.html',
+      'views/layouts/application.html.erb',
+      'src/App.vue', 'src/layouts/default.vue',
+      'src/app.component.html',
+      'layouts/default.vue', 'layouts/default.html',
+      'base.html', 'layout.html', 'master.html',
+    ];
+
+    for (const layoutPath of knownLayouts) {
+      const fullPath = path.join(this.projectRoot, layoutPath);
+      if (fs.existsSync(fullPath) && fs.statSync(fullPath).isFile()) {
+        points.add(fullPath);
+      }
+    }
+
+    const layoutPatterns = [
+      '**/*layout*', '**/*base*', '**/*master*',
+      '**/*_app.*', '**/*app.component.*',
+    ];
+    for (const pattern of layoutPatterns) {
+      try {
+        const files = await glob(pattern, { cwd: this.projectRoot, nodir: true, ignore: '**/node_modules/**' });
+        for (const f of files) {
+          const fullPath = path.join(this.projectRoot, f);
+          if (fs.existsSync(fullPath)) {
+            const content = fs.readFileSync(fullPath, 'utf-8');
+            if (content.includes('</body>') || content.includes('</html>') || content.includes('<!DOCTYPE')) {
+              points.add(fullPath);
+            }
+          }
+        }
+      } catch (e) {}
+    }
+
+    const publicDirs = ['public', 'www', 'web', 'htdocs', 'static'];
+    for (const dir of publicDirs) {
+      const dirPath = path.join(this.projectRoot, dir);
+      if (fs.existsSync(dirPath)) {
+        try {
+          const files = await glob('**/*.html', { cwd: dirPath, nodir: true });
+          for (const f of files) {
+            const fullPath = path.join(dirPath, f);
+            const content = fs.readFileSync(fullPath, 'utf-8');
+            if (content.includes('<!DOCTYPE') || content.includes('<html')) {
+              points.add(fullPath);
+            }
+          }
+        } catch (e) {}
+      }
+    }
+
+    if (points.size === 0) {
+      try {
+        const rootHtmlFiles = await glob('*.html', { cwd: this.projectRoot, nodir: true });
+        for (const f of rootHtmlFiles) {
+          const fullPath = path.join(this.projectRoot, f);
+          const content = fs.readFileSync(fullPath, 'utf-8');
+          if (content.includes('<!DOCTYPE') || content.includes('<html')) {
+            points.add(fullPath);
+          }
+        }
+      } catch (e) {}
+
+      try {
+        const phpFiles = await glob('**/*.php', { cwd: this.projectRoot, nodir: true, ignore: '**/node_modules/**' });
+        for (const f of phpFiles.slice(0, 30)) {
+          const fullPath = path.join(this.projectRoot, f);
+          const content = fs.readFileSync(fullPath, 'utf-8');
+          if (content.includes('<!DOCTYPE') || content.includes('<html')) {
+            points.add(fullPath);
+          }
+        }
+      } catch (e) {}
+    }
+
+    if (points.size === 0) {
+      try {
+        const allHtml = await glob('**/*.html', { cwd: this.projectRoot, nodir: true, ignore: '**/node_modules/**' });
+        for (const f of allHtml) {
+          const fullPath = path.join(this.projectRoot, f);
+          points.add(fullPath);
+        }
+      } catch (e) {}
+    }
+
+    return [...points];
+  }
+
+  createLoaderFile() {
+    const loaderPath = path.join(this.projectRoot, '_lwazi_loader.js');
+    const content = `// Lwazi 2.0 Widget Loader
+// Add this script to your HTML layout file to enable the Lwazi chat widget.
+// 
+// Insert before </body> in your layout/template:
+//
+//   <script src="${this.lwaziServer}/widget/lwazi-widget.js" data-project-id="${this.projectId}" data-server="${this.lwaziServer}" defer></script>
+//
+// Lwazi couldn't find an HTML/template file to inject automatically.
+// See https://opencode.ai/lwazi for manual integration help.
+console.log('Lwazi 2.0: Widget not auto-injected. See instructions in this file.');
+`;
+    fs.writeFileSync(loaderPath, content, 'utf-8');
+  }
+
+  report() {
+    console.log('\n' + '='.repeat(60));
+    console.log('  Lwazi Widget Injection Report');
+    console.log('='.repeat(60));
+
+    for (const file of this.injected) {
+      const rel = path.relative(this.projectRoot, file);
+      console.log(`  ✓ Widget injected into: ${rel}`);
+    }
+
+    for (const { file, error } of this.failed) {
+      const rel = path.relative(this.projectRoot, file);
+      console.log(`  ✗ Failed to inject into: ${rel} (${error})`);
+    }
+
+    if (this.injected.length === 0 && !this.failed.length) {
+      console.log(`\n  ⚠  Could not find HTML/template files to inject into.`);
+      console.log(`  Created _lwazi_loader.js with manual instructions.`);
+      console.log(`  Add this to your layout manually:`);
+      console.log(`    <script src="${this.lwaziServer}/widget/lwazi-widget.js" data-project-id="${this.projectId}" data-server="${this.lwaziServer}" defer></script>`);
+    }
+
+    console.log('='.repeat(60) + '\n');
+  }
+}

package/lib/project_probe.js

@@ -0,0 +1,234 @@
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+
+export class ProjectProbe {
+  constructor(projectRoot) {
+    this.projectRoot = path.resolve(projectRoot);
+  }
+
+  probe() {
+    const result = {
+      has_package_json: false,
+      has_composer_json: false,
+      has_requirements_txt: false,
+      has_gemfile: false,
+      has_manage_py: false,
+      has_artisan: false,
+      has_makefile: false,
+      has_dockerfile: false,
+      html_files_count: 0,
+      php_files_count: 0,
+      js_files_count: 0,
+      py_files_count: 0,
+      rb_files_count: 0,
+      go_files_count: 0,
+      rs_files_count: 0,
+      java_files_count: 0,
+      cs_files_count: 0,
+      other_extensions: new Set(),
+      root_files: [],
+      subdirectories: [],
+      likely_entry_files: [],
+      framework_guess: 'Unknown',
+      confidence: 'unknown',
+      template_engines: [],
+      public_dirs: [],
+    };
+
+    try {
+      const entries = fs.readdirSync(this.projectRoot, { withFileTypes: true });
+      for (const entry of entries) {
+        if (entry.isFile()) {
+          result.root_files.push(entry.name);
+          const ext = path.extname(entry.name).toLowerCase();
+          const basename = entry.name.toLowerCase();
+
+          if (basename === 'package.json') result.has_package_json = true;
+          if (basename === 'composer.json') result.has_composer_json = true;
+          if (basename === 'requirements.txt') result.has_requirements_txt = true;
+          if (basename === 'gemfile' || basename === 'gemfile.lock') result.has_gemfile = true;
+          if (basename === 'manage.py') result.has_manage_py = true;
+          if (basename === 'artisan') result.has_artisan = true;
+          if (basename === 'makefile' || basename === 'makefile') result.has_makefile = true;
+          if (basename === 'dockerfile') result.has_dockerfile = true;
+
+          if (ext === '.html' || ext === '.htm') result.html_files_count++;
+          else if (ext === '.php') result.php_files_count++;
+          else if (ext === '.js' || ext === '.jsx') result.js_files_count++;
+          else if (ext === '.py') result.py_files_count++;
+          else if (ext === '.rb') result.rb_files_count++;
+          else if (ext === '.go') result.go_files_count++;
+          else if (ext === '.rs') result.rs_files_count++;
+          else if (ext === '.java') result.java_files_count++;
+          else if (ext === '.cs') result.cs_files_count++;
+          else if (ext) result.other_extensions.add(ext);
+
+          if (/^index\./.test(basename) || /^main\./.test(basename) || /^app\./.test(basename) || /^server\./.test(basename)) {
+            result.likely_entry_files.push(entry.name);
+          }
+        } else if (entry.isDirectory()) {
+          const dirname = entry.name.toLowerCase();
+          result.subdirectories.push(entry.name);
+          if (['public', 'www', 'web', 'htdocs', 'static', 'dist'].includes(dirname)) {
+            result.public_dirs.push(entry.name);
+          }
+          if (['views', 'templates', 'pages', 'components', 'layouts'].includes(dirname)) {
+            if (dirname === 'views' || dirname === 'templates') result.template_engines.push(dirname);
+          }
+        }
+      }
+    } catch (err) {
+      return result;
+    }
+
+    result.other_extensions = [...result.other_extensions].sort();
+
+    result.framework_guess = this.guessFramework(result);
+    result.confidence = result.framework_guess === 'Unknown' ? 'unknown' : 'medium';
+
+    return result;
+  }
+
+  guessFramework(probe) {
+    if (probe.has_package_json) {
+      try {
+        const pkgPath = path.join(this.projectRoot, 'package.json');
+        const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'));
+        const deps = { ...pkg.dependencies, ...pkg.devDependencies };
+        const depNames = Object.keys(deps).join(' ').toLowerCase();
+
+        if (depNames.includes('next')) return 'Next.js';
+        if (depNames.includes('nuxt')) return 'Nuxt.js';
+        if (depNames.includes('sveltekit') || (depNames.includes('svelte') && depNames.includes('@sveltejs/kit'))) return 'SvelteKit';
+        if (depNames.includes('@angular') || depNames.includes('angular')) return 'Angular';
+        if (depNames.includes('vue') && depNames.includes('vue-router')) return 'Vue.js';
+        if (depNames.includes('react') && depNames.includes('react-router')) return 'React';
+        if (depNames.includes('express')) return 'Express';
+        if (depNames.includes('gatsby')) return 'Gatsby';
+        if (depNames.includes('astro')) return 'Astro';
+        if (depNames.includes('remix')) return 'Remix';
+        if (depNames.includes('docusaurus')) return 'Docusaurus';
+        if (depNames.includes('eleventy') || depNames.includes('11ty')) return 'Eleventy';
+        if (depNames.includes('hugo') || depNames.includes('gohugo')) return 'Hugo';
+        if (depNames.includes('jekyll')) return 'Jekyll';
+
+        if (depNames.includes('webpack') || depNames.includes('vite') || depNames.includes('parcel')) {
+          return 'JavaScript (build tool)';
+        }
+      } catch (e) {}
+    }
+
+    if (probe.has_composer_json) {
+      try {
+        const composerPath = path.join(this.projectRoot, 'composer.json');
+        const composer = JSON.parse(fs.readFileSync(composerPath, 'utf-8'));
+        const reqs = { ...composer.require, ...composer['require-dev'] };
+        const reqNames = Object.keys(reqs).join(' ').toLowerCase();
+        if (reqNames.includes('laravel')) return 'Laravel';
+        if (reqNames.includes('symfony')) return 'Symfony';
+        if (reqNames.includes('cakephp')) return 'CakePHP';
+        if (reqNames.includes('codeigniter')) return 'CodeIgniter';
+        if (reqNames.includes('yii')) return 'Yii';
+        if (reqNames.includes('wordpress') || reqNames.includes('wp-')) return 'WordPress';
+        if (reqNames.includes('drupal')) return 'Drupal';
+        if (reqNames.includes('joomla')) return 'Joomla';
+        if (reqNames.includes('magento')) return 'Magento';
+        if (reqNames.includes('shopify')) return 'Shopify';
+        return 'PHP';
+      } catch (e) {}
+    }
+
+    if (probe.has_requirements_txt || probe.has_manage_py) {
+      if (probe.has_manage_py) return 'Django';
+      try {
+        const reqPath = path.join(this.projectRoot, 'requirements.txt');
+        const reqs = fs.readFileSync(reqPath, 'utf-8').toLowerCase();
+        if (reqs.includes('flask')) return 'Flask';
+        if (reqs.includes('fastapi')) return 'FastAPI';
+        if (reqs.includes('django')) return 'Django';
+        if (reqs.includes('pyramid')) return 'Pyramid';
+        if (reqs.includes('tornado')) return 'Tornado';
+        if (reqs.includes('bottle')) return 'Bottle';
+        return 'Python';
+      } catch (e) {
+        return 'Python';
+      }
+    }
+
+    if (probe.has_gemfile) {
+      try {
+        const gemfile = fs.readFileSync(path.join(this.projectRoot, 'Gemfile'), 'utf-8').toLowerCase();
+        if (gemfile.includes('rails')) return 'Ruby on Rails';
+        if (gemfile.includes('sinatra')) return 'Sinatra';
+        if (gemfile.includes('jekyll')) return 'Jekyll';
+        if (gemfile.includes('middleman')) return 'Middleman';
+        return 'Ruby';
+      } catch (e) {}
+    }
+
+    if (probe.has_artisan) return 'Laravel';
+
+    if (probe.php_files_count > 3) return 'PHP (custom)';
+
+    if (probe.html_files_count > 3 && probe.js_files_count === 0) return 'Static HTML';
+
+    if (probe.js_files_count > 3) return 'JavaScript';
+
+    if (probe.py_files_count > 3) return 'Python';
+
+    if (probe.go_files_count > 3) return 'Go';
+
+    if (probe.rs_files_count > 3) return 'Rust';
+
+    if (probe.java_files_count > 3) return 'Java';
+
+    if (probe.cs_files_count > 3) return 'C#';
+
+    return 'Unknown';
+  }
+
+  display(probe) {
+    console.log('\n' + '='.repeat(60));
+    console.log('  LWazi Project Probe Results');
+    console.log('='.repeat(60));
+
+    const guessStr = probe.framework_guess !== 'Unknown' ? probe.framework_guess : 'custom project structure';
+    console.log(`\n  I found what looks like a ${guessStr} project`);
+
+    console.log(`\n  Files found in project root:`);
+    console.log(`    HTML files: ${probe.html_files_count}`);
+    console.log(`    PHP files:  ${probe.php_files_count}`);
+    console.log(`    JS files:   ${probe.js_files_count}`);
+    console.log(`    Python:     ${probe.py_files_count}`);
+    console.log(`    Ruby:       ${probe.rb_files_count}`);
+    console.log(`    Other ext.: ${probe.other_extensions.join(', ')}`);
+
+    if (probe.subdirectories.length > 0) {
+      console.log(`\n  Directories: ${probe.subdirectories.join(', ')}`);
+    }
+
+    if (probe.likely_entry_files.length > 0) {
+      console.log(`\n  Likely entry files: ${probe.likely_entry_files.join(', ')}`);
+    }
+
+    if (probe.template_engines.length > 0) {
+      console.log(`  Template engines detected: ${probe.template_engines.join(', ')}`);
+    }
+
+    if (probe.public_dirs.length > 0) {
+      console.log(`  Public directories: ${probe.public_dirs.join(', ')}`);
+    }
+
+    if (probe.confidence === 'unknown' || probe.framework_guess === 'Unknown') {
+      console.log(`\n  I found a custom project structure — Lwazi will analyse it intelligently.`);
+      console.log(`  The AI-powered indexer will understand your project without assumptions.`);
+    } else {
+      console.log(`\n  Lwazi will use its AI-powered indexer to deeply understand your project.`);
+    }
+
+    console.log('='.repeat(60) + '\n');
+  }
+}

package/lib/sync.js

@@ -0,0 +1,92 @@
+import fs from 'fs';
+import path from 'path';
+import axios from 'axios';
+
+export class Sync {
+  constructor(projectRoot) {
+    this.projectRoot = path.resolve(projectRoot);
+    this.configPath = path.join(this.projectRoot, 'lwazi.config.json');
+  }
+
+  async sync() {
+    if (!fs.existsSync(this.configPath)) {
+      console.error('No lwazi.config.json found. Run "lwazi-2.0 init" first.');
+      process.exit(1);
+    }
+
+    const config = JSON.parse(fs.readFileSync(this.configPath, 'utf-8'));
+    const serverUrl = config.lwazi_server || 'http://localhost:11500';
+
+    console.log('\nRe-indexing project...\n');
+
+    try {
+      const response = await axios.post(`${serverUrl}/index`, {
+        project_id: config.project_id,
+        project_root: this.projectRoot,
+        base_url: config.base_url,
+        project_name: config.project_name,
+        max_crawl_pages: config.max_crawl_pages || 500,
+        skip_paths: config.skip_paths || []
+      }, {
+        responseType: 'stream',
+        timeout: 600000
+      });
+
+      const stream = response.data;
+      let resultData = '';
+
+      for await (const chunk of stream) {
+        const text = chunk.toString();
+        const lines = text.split('\n').filter(l => l.trim());
+
+        for (const line of lines) {
+          if (line.startsWith('data:')) {
+            const data = line.slice(5).trim();
+            if (data === '[DONE]') break;
+            try {
+              const parsed = JSON.parse(data);
+              if (parsed.event === 'progress') {
+                process.stdout.write(`\r  ${parsed.data}`);
+              } else if (parsed.event === 'complete') {
+                resultData = parsed.data;
+              } else if (parsed.event === 'error') {
+                console.error(`\n  Error: ${parsed.data}`);
+              }
+            } catch (e) {
+              if (data && !data.startsWith('[')) {
+                process.stdout.write(`\r  ${data}`);
+              }
+            }
+          }
+        }
+      }
+
+      console.log('\n');
+
+      if (resultData) {
+        try {
+          const result = JSON.parse(resultData);
+          console.log('  Sync complete!');
+          console.log(`  Files indexed: ${result.files_indexed}`);
+          console.log(`  Routes found:  ${result.routes_found}`);
+          console.log(`  Pages crawled: ${result.pages_indexed}`);
+          console.log(`  Duration:      ${result.duration_seconds}s`);
+        } catch (e) {
+          console.log('  Sync completed (could not parse result).');
+        }
+      }
+
+      config.last_synced = new Date().toISOString();
+      fs.writeFileSync(this.configPath, JSON.stringify(config, null, 2));
+
+    } catch (err) {
+      if (err.code === 'ECONNREFUSED') {
+        console.error('  Error: Could not reach Lwazi server at', serverUrl);
+        console.error('  Make sure the Lwazi server is running.');
+      } else {
+        console.error('  Error during sync:', err.message);
+      }
+      process.exit(1);
+    }
+  }
+}

package/package.json

@@ -0,0 +1,23 @@
+{
+  "name": "lwazi-2.0",
+  "version": "0.1.0",
+  "description": "Intelligent project-aware AI chatbot. Works with any website.",
+  "author": "Nigel Nkomo <nigel.nkomo@gmail.com>",
+  "type": "module",
+  "bin": {
+    "lwazi-2.0": "./bin/lwazi.js"
+  },
+  "scripts": {
+    "link": "npm link",
+    "install:global": "npm install -g ."
+  },
+  "dependencies": {
+    "axios": "^1.6.0",
+    "bcryptjs": "^2.4.3",
+    "chalk": "^5.3.0",
+    "inquirer": "^9.2.0",
+    "nanoid": "^5.0.0",
+    "glob": "^10.3.0",
+    "cheerio": "^1.0.0"
+  }
+}