chainlesschain 0.37.8 → 0.37.10

package/src/commands/browse.js

@@ -0,0 +1,184 @@
+/**
+ * Browser automation commands
+ * chainlesschain browse <url> | browse scrape <url> | browse screenshot <url>
+ */
+
+import chalk from "chalk";
+import ora from "ora";
+import { logger } from "../lib/logger.js";
+import {
+  fetchPage,
+  extractText,
+  extractTitle,
+  extractMeta,
+  querySelectorAll,
+  extractLinks,
+  takeScreenshot,
+} from "../lib/browser-automation.js";
+
+export function registerBrowseCommand(program) {
+  const browse = program
+    .command("browse")
+    .description("Headless browser automation and web scraping");
+
+  // browse fetch — fetch and display page content
+  browse
+    .command("fetch")
+    .description("Fetch a URL and display text content")
+    .argument("<url>", "URL to fetch")
+    .option("--html", "Show raw HTML instead of text")
+    .option("--links", "Extract links only")
+    .option("--json", "Output as JSON")
+    .action(async (url, options) => {
+      try {
+        const spinner = ora(`Fetching ${url}...`).start();
+        const result = await fetchPage(url);
+        spinner.stop();
+
+        const title = extractTitle(result.html);
+        const text = extractText(result.html);
+        const description = extractMeta(result.html);
+
+        if (options.json) {
+          const output = {
+            url: result.url,
+            status: result.status,
+            title,
+            description,
+            size: result.size,
+          };
+          if (options.html) output.html = result.html;
+          else if (options.links)
+            output.links = extractLinks(result.html, result.url);
+          else output.text = text;
+          console.log(JSON.stringify(output, null, 2));
+          return;
+        }
+
+        if (options.links) {
+          const links = extractLinks(result.html, result.url);
+          logger.log(
+            chalk.bold(`Links from ${title || url} (${links.length}):\n`),
+          );
+          for (const link of links.slice(0, 50)) {
+            logger.log(
+              `  ${chalk.cyan(link.text.substring(0, 60).padEnd(62))} ${chalk.gray(link.href)}`,
+            );
+          }
+          if (links.length > 50)
+            logger.log(chalk.gray(`  ... and ${links.length - 50} more`));
+          return;
+        }
+
+        if (options.html) {
+          console.log(result.html);
+          return;
+        }
+
+        logger.log(chalk.bold(title || url));
+        if (description) logger.log(chalk.gray(description));
+        logger.log(
+          chalk.gray(`${result.size} bytes | ${result.contentType}\n`),
+        );
+        logger.log(text.substring(0, 5000));
+        if (text.length > 5000) {
+          logger.log(
+            chalk.gray(`\n... truncated (${text.length} chars total)`),
+          );
+        }
+      } catch (err) {
+        logger.error(`Fetch failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  // browse scrape — scrape elements matching a CSS selector
+  browse
+    .command("scrape")
+    .description("Scrape elements from a URL using CSS selector")
+    .argument("<url>", "URL to scrape")
+    .requiredOption("-s, --selector <css>", "CSS selector (tag, .class, #id)")
+    .option("-n, --limit <n>", "Max results", "20")
+    .option("--json", "Output as JSON")
+    .action(async (url, options) => {
+      try {
+        const spinner = ora(`Scraping ${url}...`).start();
+        const result = await fetchPage(url);
+        const elements = querySelectorAll(result.html, options.selector);
+        spinner.stop();
+
+        const limit = parseInt(options.limit) || 20;
+        const limited = elements.slice(0, limit);
+
+        if (options.json) {
+          console.log(
+            JSON.stringify(
+              {
+                url: result.url,
+                selector: options.selector,
+                count: elements.length,
+                results: limited.map((e) => ({ text: e.text })),
+              },
+              null,
+              2,
+            ),
+          );
+          return;
+        }
+
+        if (elements.length === 0) {
+          logger.info(`No elements matching "${options.selector}"`);
+        } else {
+          logger.log(
+            chalk.bold(
+              `Scraped ${elements.length} elements matching "${options.selector}":\n`,
+            ),
+          );
+          for (let i = 0; i < limited.length; i++) {
+            const text = limited[i].text.substring(0, 200).replace(/\n/g, " ");
+            logger.log(`  ${chalk.gray(`[${i + 1}]`)} ${text}`);
+          }
+          if (elements.length > limit) {
+            logger.log(chalk.gray(`  ... ${elements.length - limit} more`));
+          }
+        }
+      } catch (err) {
+        logger.error(`Scrape failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  // browse screenshot — take a screenshot (requires playwright)
+  browse
+    .command("screenshot")
+    .description("Take a screenshot of a URL (requires playwright)")
+    .argument("<url>", "URL to screenshot")
+    .option("-o, --output <path>", "Output file path", "screenshot.png")
+    .option("--width <n>", "Viewport width", "1280")
+    .option("--height <n>", "Viewport height", "720")
+    .option("--full-page", "Capture full page")
+    .option("--json", "Output as JSON")
+    .action(async (url, options) => {
+      try {
+        const spinner = ora(`Taking screenshot of ${url}...`).start();
+        const result = await takeScreenshot(url, options.output, {
+          width: parseInt(options.width),
+          height: parseInt(options.height),
+          fullPage: !!options.fullPage,
+        });
+        spinner.stop();
+
+        if (options.json) {
+          console.log(JSON.stringify(result, null, 2));
+        } else if (result.success) {
+          logger.success(`Screenshot saved: ${chalk.cyan(result.path)}`);
+        } else {
+          logger.error(result.error);
+          logger.info("Install playwright: npm install -g playwright");
+        }
+      } catch (err) {
+        logger.error(`Screenshot failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+}

package/src/commands/chat.js

@@ -0,0 +1,35 @@
+/**
+ * Interactive AI chat command
+ * chainlesschain chat [--model qwen2:7b] [--provider ollama] [--agent]
+ */
+
+import { startChatRepl } from "../repl/chat-repl.js";
+import { startAgentRepl } from "../repl/agent-repl.js";
+
+export function registerChatCommand(program) {
+  program
+    .command("chat")
+    .description("Start an interactive AI chat session")
+    .option("--model <model>", "Model name", "qwen2:7b")
+    .option("--provider <provider>", "LLM provider (ollama, openai)", "ollama")
+    .option("--base-url <url>", "API base URL")
+    .option("--api-key <key>", "API key")
+    .option(
+      "--agent",
+      "Agentic mode - AI can read/write files and run commands (like Claude Code)",
+    )
+    .action(async (options) => {
+      const replOptions = {
+        model: options.model,
+        provider: options.provider,
+        baseUrl: options.baseUrl,
+        apiKey: options.apiKey,
+      };
+
+      if (options.agent) {
+        await startAgentRepl(replOptions);
+      } else {
+        await startChatRepl(replOptions);
+      }
+    });
+}

package/src/commands/db.js

@@ -0,0 +1,152 @@
+/**
+ * Database management commands
+ * chainlesschain db init|info|backup|restore|migrate
+ */
+
+import ora from "ora";
+import chalk from "chalk";
+import { logger } from "../lib/logger.js";
+import { bootstrap, shutdown } from "../runtime/bootstrap.js";
+
+export function registerDbCommand(program) {
+  const db = program.command("db").description("Database management");
+
+  // db init
+  db.command("init")
+    .description("Initialize the database")
+    .option("--path <path>", "Custom database path")
+    .option("--force", "Overwrite existing database")
+    .action(async (options) => {
+      const spinner = ora("Initializing database...").start();
+      try {
+        const ctx = await bootstrap({
+          dbPath: options.path,
+          verbose: program.opts().verbose,
+        });
+
+        if (!ctx.db) {
+          spinner.fail("Failed to initialize database");
+          process.exit(1);
+        }
+
+        const info = ctx.db.getInfo();
+        spinner.succeed("Database initialized");
+        logger.log(`  Path: ${chalk.cyan(info.path)}`);
+        logger.log(`  Driver: ${chalk.cyan(info.driver)}`);
+        logger.log(`  Tables: ${chalk.cyan(info.tableCount)}`);
+
+        await shutdown();
+      } catch (err) {
+        spinner.fail(`Database init failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  // db info
+  db.command("info")
+    .description("Show database information")
+    .option("--json", "Output as JSON")
+    .action(async (options) => {
+      try {
+        const ctx = await bootstrap({ verbose: program.opts().verbose });
+
+        if (!ctx.db) {
+          logger.error("No database available");
+          process.exit(1);
+        }
+
+        const info = ctx.db.getInfo();
+
+        if (options.json) {
+          console.log(JSON.stringify(info, null, 2));
+        } else {
+          logger.log(chalk.bold("Database Info:"));
+          logger.log(`  Path:       ${chalk.cyan(info.path)}`);
+          logger.log(`  Driver:     ${chalk.cyan(info.driver)}`);
+          logger.log(
+            `  Encrypted:  ${info.encrypted ? chalk.green("Yes") : chalk.gray("No")}`,
+          );
+          logger.log(`  Size:       ${chalk.cyan(info.fileSizeMB + " MB")}`);
+          logger.log(`  Tables:     ${chalk.cyan(info.tableCount)}`);
+          if (info.tables.length > 0) {
+            logger.log(
+              `  Table list: ${chalk.gray(info.tables.slice(0, 10).join(", "))}${info.tables.length > 10 ? "..." : ""}`,
+            );
+          }
+        }
+
+        await shutdown();
+      } catch (err) {
+        logger.error(`Failed to get db info: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  // db backup
+  db.command("backup")
+    .description("Create database backup")
+    .argument("[output]", "Backup file path")
+    .action(async (output) => {
+      const spinner = ora("Creating backup...").start();
+      try {
+        const ctx = await bootstrap({ verbose: program.opts().verbose });
+
+        if (!ctx.db) {
+          spinner.fail("No database to backup");
+          process.exit(1);
+        }
+
+        const timestamp = new Date().toISOString().replace(/[:.]/g, "-");
+        const backupPath =
+          output || `${ctx.env.dataDir}/chainlesschain.db.backup.${timestamp}`;
+
+        ctx.db.backup(backupPath);
+        spinner.succeed(`Backup created: ${chalk.cyan(backupPath)}`);
+
+        await shutdown();
+      } catch (err) {
+        spinner.fail(`Backup failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  // db restore
+  db.command("restore")
+    .description("Restore database from backup")
+    .argument("<backup>", "Backup file path")
+    .option("--force", "Skip confirmation")
+    .action(async (backup, options) => {
+      try {
+        const fs = await import("fs");
+        if (!fs.existsSync(backup)) {
+          logger.error(`Backup file not found: ${backup}`);
+          process.exit(1);
+        }
+
+        if (!options.force) {
+          const { confirm } = await import("@inquirer/prompts");
+          const ok = await confirm({
+            message: "This will overwrite the current database. Continue?",
+          });
+          if (!ok) {
+            logger.info("Restore cancelled");
+            return;
+          }
+        }
+
+        const ctx = await bootstrap({
+          skipDb: true,
+          verbose: program.opts().verbose,
+        });
+        const dbPath = `${ctx.env.dataDir}/chainlesschain.db`;
+
+        fs.copyFileSync(backup, dbPath);
+        logger.success(`Database restored from ${chalk.cyan(backup)}`);
+
+        await shutdown();
+      } catch (err) {
+        logger.error(`Restore failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+}