chainlesschain 0.37.7 → 0.37.9

package/README.md

@@ -102,6 +102,100 @@ chainlesschain doctor
 
 Checks: Node.js version, npm, Docker, Docker Compose, Git, config directory, binary installation, setup status, port availability, disk space.
 
+---
+
+## Headless Commands
+
+These commands work without the desktop GUI, using core packages directly.
+
+### `chainlesschain db <action>`
+
+Database management.
+
+```bash
+chainlesschain db init                  # Initialize the database
+chainlesschain db init --path ./my.db   # Custom database path
+chainlesschain db info                  # Show database info (driver, tables, size)
+chainlesschain db info --json           # JSON output
+chainlesschain db backup [output]       # Create backup
+chainlesschain db restore <backup>      # Restore from backup
+```
+
+### `chainlesschain note <action>`
+
+Note and knowledge base management.
+
+```bash
+chainlesschain note add "My Note" -c "Content here" -t "tag1,tag2"
+chainlesschain note list                # List recent notes
+chainlesschain note list --category dev --tag important
+chainlesschain note show <id>           # Show note by ID prefix
+chainlesschain note search "keyword"    # Full-text search
+chainlesschain note delete <id>         # Soft delete
+```
+
+### `chainlesschain chat`
+
+Start an interactive AI chat session with streaming output.
+
+```bash
+chainlesschain chat                     # Default: Ollama qwen2:7b
+chainlesschain chat --model llama3      # Use different model
+chainlesschain chat --provider openai --api-key sk-...
+chainlesschain chat --agent             # Agentic mode (can read/write files)
+```
+
+Slash commands in chat: `/exit`, `/model`, `/provider`, `/clear`, `/history`, `/help`
+
+### `chainlesschain ask <question>`
+
+Single-shot AI question (non-interactive).
+
+```bash
+chainlesschain ask "What is WebRTC?"
+chainlesschain ask "Explain this code" --model gpt-4o --provider openai
+chainlesschain ask "Hello" --json       # JSON output with question/answer/model
+```
+
+### `chainlesschain llm <action>`
+
+LLM provider management.
+
+```bash
+chainlesschain llm models               # List installed Ollama models
+chainlesschain llm models --json        # JSON output
+chainlesschain llm test                 # Test Ollama connectivity
+chainlesschain llm test --provider openai --api-key sk-...
+```
+
+### `chainlesschain agent` (alias: `a`)
+
+Start an agentic AI session — the AI can read/write files, run shell commands, search the codebase, and invoke 138 built-in skills.
+
+```bash
+chainlesschain agent                    # Default: Ollama qwen2:7b
+chainlesschain a --model llama3         # Short alias
+chainlesschain agent --provider openai --api-key sk-...
+```
+
+Built-in tools: `read_file`, `write_file`, `edit_file`, `run_shell`, `search_files`, `list_dir`, `run_skill`, `list_skills`
+
+### `chainlesschain skill <action>`
+
+Manage and run 138 built-in AI skills.
+
+```bash
+chainlesschain skill list               # List all skills grouped by category
+chainlesschain skill list --category automation
+chainlesschain skill list --tag code --runnable
+chainlesschain skill list --json        # JSON output
+chainlesschain skill categories         # Show category breakdown
+chainlesschain skill info code-review   # Detailed skill info + docs
+chainlesschain skill info code-review --json
+chainlesschain skill search "browser"   # Search by keyword
+chainlesschain skill run code-review "Review this function..."
+```
+
 ## Global Options
 
 ```bash
@@ -171,12 +265,23 @@ Configuration is stored at `~/.chainlesschain/config.json`. The CLI creates and
 ```bash
 cd packages/cli
 npm install
-npm test                # Run all tests
-npm run test:unit       # Unit tests only
-npm run test:integration # Integration tests
-npm run test:e2e        # End-to-end tests
+npm test                # Run all tests (117 tests across 18 files)
+npm run test:unit       # Unit tests only (10 files)
+npm run test:integration # Integration tests (3 files)
+npm run test:e2e        # End-to-end tests (5 files)
 ```
 
+### Test Coverage
+
+| Category           | Files  | Tests   | Status          |
+| ------------------ | ------ | ------- | --------------- |
+| Unit — lib modules | 8      | 52      | All passing     |
+| Unit — commands    | 3      | 31      | All passing     |
+| Unit — runtime     | 1      | 6       | All passing     |
+| Integration        | 3      | 7       | All passing     |
+| E2E                | 3      | 21      | All passing     |
+| **Total**          | **18** | **117** | **All passing** |
+
 ## License
 
 MIT

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "chainlesschain",
-  "version": "0.37.7",
+  "version": "0.37.9",
   "description": "CLI for ChainlessChain - install, configure, and manage your personal AI management system",
   "type": "module",
   "bin": {
@@ -45,7 +45,12 @@
     "@inquirer/prompts": "^7.2.0",
     "chalk": "^5.4.1",
     "ora": "^8.1.1",
-    "semver": "^7.6.3"
+    "semver": "^7.6.3",
+    "@chainlesschain/core-env": "0.1.0",
+    "@chainlesschain/shared-logger": "0.1.0",
+    "@chainlesschain/core-db": "0.1.0",
+    "@chainlesschain/core-config": "0.1.0",
+    "@chainlesschain/core-infra": "0.1.0"
   },
   "devDependencies": {
     "vitest": "^3.1.1"

package/src/commands/agent.js

@@ -0,0 +1,30 @@
+/**
+ * Agentic AI assistant - Claude Code style
+ * chainlesschain agent [--model] [--provider]
+ *
+ * User describes what they want in natural language.
+ * AI reads files, writes code, runs commands, and explains what it's doing.
+ */
+
+import { startAgentRepl } from "../repl/agent-repl.js";
+
+export function registerAgentCommand(program) {
+  program
+    .command("agent")
+    .alias("a")
+    .description(
+      "Start an agentic AI session (reads/writes files, runs commands)",
+    )
+    .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")
+    .action(async (options) => {
+      await startAgentRepl({
+        model: options.model,
+        provider: options.provider,
+        baseUrl: options.baseUrl,
+        apiKey: options.apiKey,
+      });
+    });
+}

package/src/commands/ask.js

@@ -0,0 +1,114 @@
+/**
+ * Single-shot AI question command
+ * chainlesschain ask "What is..." [--model qwen2:7b] [--provider ollama] [--json]
+ */
+
+import ora from "ora";
+import chalk from "chalk";
+import { logger } from "../lib/logger.js";
+
+/**
+ * Send a single question to an LLM provider
+ * @param {string} question
+ * @param {object} options
+ * @returns {Promise<string>}
+ */
+async function queryLLM(question, options = {}) {
+  const provider = options.provider || "ollama";
+  const model = options.model || "qwen2:7b";
+  const baseUrl = options.baseUrl || "http://localhost:11434";
+
+  if (provider === "ollama") {
+    const response = await fetch(`${baseUrl}/api/generate`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        model,
+        prompt: question,
+        stream: false,
+      }),
+    });
+
+    if (!response.ok) {
+      throw new Error(
+        `Ollama error: ${response.status} ${response.statusText}`,
+      );
+    }
+
+    const data = await response.json();
+    return data.response;
+  } else if (provider === "openai") {
+    const apiKey = options.apiKey || process.env.OPENAI_API_KEY;
+    if (!apiKey)
+      throw new Error("OpenAI API key required (--api-key or OPENAI_API_KEY)");
+
+    const apiBase = options.baseUrl || "https://api.openai.com/v1";
+    const response = await fetch(`${apiBase}/chat/completions`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${apiKey}`,
+      },
+      body: JSON.stringify({
+        model: model || "gpt-4o-mini",
+        messages: [{ role: "user", content: question }],
+      }),
+    });
+
+    if (!response.ok) {
+      throw new Error(
+        `OpenAI error: ${response.status} ${response.statusText}`,
+      );
+    }
+
+    const data = await response.json();
+    return data.choices[0].message.content;
+  }
+
+  throw new Error(`Unsupported provider: ${provider}`);
+}
+
+export function registerAskCommand(program) {
+  program
+    .command("ask")
+    .description("Ask a question to the AI (single-shot)")
+    .argument("<question>", "The question to ask")
+    .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("--json", "Output as JSON")
+    .action(async (question, options) => {
+      const spinner = ora("Thinking...").start();
+      try {
+        const answer = await queryLLM(question, {
+          model: options.model,
+          provider: options.provider,
+          baseUrl: options.baseUrl,
+          apiKey: options.apiKey,
+        });
+
+        spinner.stop();
+
+        if (options.json) {
+          console.log(
+            JSON.stringify(
+              {
+                question,
+                answer,
+                model: options.model,
+                provider: options.provider,
+              },
+              null,
+              2,
+            ),
+          );
+        } else {
+          logger.log(answer);
+        }
+      } catch (err) {
+        spinner.fail(`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);
+      }
+    });
+}

package/src/commands/llm.js

@@ -0,0 +1,137 @@
+/**
+ * LLM management commands
+ * chainlesschain llm list|test|models
+ */
+
+import ora from "ora";
+import chalk from "chalk";
+import { logger } from "../lib/logger.js";
+
+export function registerLlmCommand(program) {
+  const llm = program.command("llm").description("LLM provider management");
+
+  // llm models - list available models
+  llm
+    .command("models")
+    .description("List available models from the current provider")
+    .option("--provider <provider>", "LLM provider", "ollama")
+    .option("--base-url <url>", "API base URL", "http://localhost:11434")
+    .option("--json", "Output as JSON")
+    .action(async (options) => {
+      const spinner = ora("Fetching models...").start();
+      try {
+        if (options.provider === "ollama") {
+          const response = await fetch(`${options.baseUrl}/api/tags`);
+          if (!response.ok) {
+            throw new Error(`Ollama not reachable: ${response.status}`);
+          }
+          const data = await response.json();
+          spinner.stop();
+
+          if (options.json) {
+            console.log(JSON.stringify(data.models, null, 2));
+          } else {
+            if (!data.models || data.models.length === 0) {
+              logger.info("No models installed. Run: ollama pull qwen2:7b");
+            } else {
+              logger.log(chalk.bold(`Models (${data.models.length}):\n`));
+              for (const m of data.models) {
+                const size = m.size
+                  ? chalk.gray(`(${(m.size / 1e9).toFixed(1)}GB)`)
+                  : "";
+                logger.log(`  ${chalk.cyan(m.name.padEnd(30))} ${size}`);
+              }
+            }
+          }
+        } else {
+          spinner.fail(
+            `Model listing not supported for provider: ${options.provider}`,
+          );
+        }
+      } catch (err) {
+        spinner.fail(`Failed to list models: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  // llm test - test connectivity
+  llm
+    .command("test")
+    .description("Test LLM provider connectivity")
+    .option("--provider <provider>", "LLM provider", "ollama")
+    .option("--model <model>", "Model to test", "qwen2:7b")
+    .option("--base-url <url>", "API base URL", "http://localhost:11434")
+    .option("--api-key <key>", "API key")
+    .action(async (options) => {
+      const spinner = ora(`Testing ${options.provider}...`).start();
+      try {
+        const start = Date.now();
+
+        if (options.provider === "ollama") {
+          const response = await fetch(`${options.baseUrl}/api/generate`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({
+              model: options.model,
+              prompt: "Say hi in one word.",
+              stream: false,
+            }),
+          });
+
+          if (!response.ok) {
+            throw new Error(`HTTP ${response.status}`);
+          }
+
+          const data = await response.json();
+          const elapsed = Date.now() - start;
+
+          spinner.succeed(
+            `${chalk.green("Connected")} to Ollama (${options.model}) in ${elapsed}ms`,
+          );
+          logger.log(
+            `  Response: ${chalk.gray(data.response.trim().substring(0, 100))}`,
+          );
+        } else if (options.provider === "openai") {
+          const apiKey = options.apiKey || process.env.OPENAI_API_KEY;
+          if (!apiKey) throw new Error("API key required");
+
+          const url =
+            options.baseUrl !== "http://localhost:11434"
+              ? options.baseUrl
+              : "https://api.openai.com/v1";
+
+          const response = await fetch(`${url}/chat/completions`, {
+            method: "POST",
+            headers: {
+              "Content-Type": "application/json",
+              Authorization: `Bearer ${apiKey}`,
+            },
+            body: JSON.stringify({
+              model: options.model || "gpt-4o-mini",
+              messages: [{ role: "user", content: "Say hi in one word." }],
+              max_tokens: 10,
+            }),
+          });
+
+          if (!response.ok) {
+            throw new Error(`HTTP ${response.status}`);
+          }
+
+          const data = await response.json();
+          const elapsed = Date.now() - start;
+
+          spinner.succeed(
+            `${chalk.green("Connected")} to OpenAI (${options.model || "gpt-4o-mini"}) in ${elapsed}ms`,
+          );
+          logger.log(
+            `  Response: ${chalk.gray(data.choices[0].message.content.trim())}`,
+          );
+        } else {
+          spinner.fail(`Unknown provider: ${options.provider}`);
+        }
+      } catch (err) {
+        spinner.fail(`Test failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+}