chainlesschain 0.37.9 → 0.37.10

package/README.md

@@ -132,6 +132,9 @@ 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 note history <id>        # Version history
+chainlesschain note diff <id> <v1> <v2> # Diff between versions
+chainlesschain note revert <id> <ver>   # Revert to a version
 ```
 
 ### `chainlesschain chat`
@@ -166,6 +169,9 @@ 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 llm providers            # List 7 built-in LLM providers
+chainlesschain llm add-provider <name>  # Add custom provider
+chainlesschain llm switch <name>        # Switch active provider
 ```
 
 ### `chainlesschain agent` (alias: `a`)
@@ -196,6 +202,286 @@ chainlesschain skill search "browser"   # Search by keyword
 chainlesschain skill run code-review "Review this function..."
 ```
 
+---
+
+## Phase 1: AI Intelligence Layer
+
+### `chainlesschain search <query>`
+
+BM25 hybrid keyword search across notes.
+
+```bash
+chainlesschain search "machine learning"
+chainlesschain search "API design" --mode bm25 --top-k 10
+chainlesschain search "security" --json
+```
+
+### `chainlesschain tokens <action>`
+
+Token usage tracking and cost analysis.
+
+```bash
+chainlesschain tokens show              # Current usage summary
+chainlesschain tokens breakdown         # Per-model breakdown
+chainlesschain tokens recent            # Recent usage entries
+chainlesschain tokens cache             # Cache hit/miss stats
+```
+
+### `chainlesschain memory <action>`
+
+Persistent memory management.
+
+```bash
+chainlesschain memory show              # Show all memories
+chainlesschain memory add "Always use TypeScript"
+chainlesschain memory search "coding"   # Search memories
+chainlesschain memory delete <id>       # Delete by ID prefix
+chainlesschain memory daily             # Today's daily note
+chainlesschain memory file              # Show memory file path
+```
+
+### `chainlesschain session <action>`
+
+Session persistence and management.
+
+```bash
+chainlesschain session list             # List saved sessions
+chainlesschain session show <id>        # Show session details
+chainlesschain session resume <id>      # Resume a session
+chainlesschain session export <id>      # Export as Markdown
+chainlesschain session delete <id>      # Delete a session
+```
+
+---
+
+## Phase 2: Knowledge & Content Management
+
+### `chainlesschain import <format>`
+
+Import knowledge from external sources.
+
+```bash
+chainlesschain import markdown ./docs   # Import markdown directory
+chainlesschain import evernote backup.enex  # Import Evernote ENEX
+chainlesschain import notion ./export   # Import Notion export
+chainlesschain import pdf document.pdf  # Import PDF text
+```
+
+### `chainlesschain export <format>`
+
+Export knowledge base.
+
+```bash
+chainlesschain export markdown -o ./output  # Export as Markdown files
+chainlesschain export site -o ./site        # Export as static HTML site
+```
+
+### `chainlesschain git <action>`
+
+Git integration for knowledge versioning.
+
+```bash
+chainlesschain git status               # Show git status
+chainlesschain git init                 # Initialize git repo
+chainlesschain git auto-commit          # Auto-commit all changes
+chainlesschain git hooks                # Install pre-commit hooks
+chainlesschain git history-analyze      # Analyze repo history
+```
+
+### Note Versioning
+
+```bash
+chainlesschain note history <id>        # Show version history
+chainlesschain note diff <id> <v1> <v2> # Diff between versions
+chainlesschain note revert <id> <ver>   # Revert to version
+```
+
+---
+
+## Phase 3: MCP & External Integration
+
+### `chainlesschain mcp <action>`
+
+MCP (Model Context Protocol) server management.
+
+```bash
+chainlesschain mcp servers              # List configured servers
+chainlesschain mcp add <name> -c <cmd>  # Add a server
+chainlesschain mcp remove <name>        # Remove a server
+chainlesschain mcp connect <name>       # Connect to server
+chainlesschain mcp disconnect <name>    # Disconnect
+chainlesschain mcp tools                # List available tools
+chainlesschain mcp call <server> <tool> # Call a tool
+```
+
+### `chainlesschain browse <action>`
+
+Browser automation (headless fetch-based).
+
+```bash
+chainlesschain browse fetch <url>       # Fetch page content
+chainlesschain browse scrape <url> -s "h2"  # Scrape CSS selector
+chainlesschain browse screenshot <url>  # Take screenshot (requires playwright)
+```
+
+### `chainlesschain instinct <action>`
+
+Instinct learning — tracks user preferences over time.
+
+```bash
+chainlesschain instinct show            # Show learned instincts
+chainlesschain instinct categories      # List 6 instinct categories
+chainlesschain instinct prompt          # Generate system prompt from instincts
+chainlesschain instinct delete <id>     # Delete an instinct
+chainlesschain instinct reset           # Clear all instincts
+chainlesschain instinct decay           # Decay old instincts
+```
+
+---
+
+## Phase 4: Security & Identity
+
+### `chainlesschain did <action>`
+
+DID identity management (Ed25519).
+
+```bash
+chainlesschain did create --label "My Identity"
+chainlesschain did list
+chainlesschain did show <did>
+chainlesschain did sign <did> "message"
+chainlesschain did verify <did> "message" <signature>
+chainlesschain did export <did>
+chainlesschain did set-default <did>
+chainlesschain did delete <did>
+```
+
+### `chainlesschain encrypt / decrypt`
+
+AES-256-GCM file encryption.
+
+```bash
+chainlesschain encrypt file <input> -o <output>
+chainlesschain encrypt db
+chainlesschain encrypt info <file>
+chainlesschain encrypt status
+chainlesschain decrypt file <input> -o <output>
+chainlesschain decrypt db
+```
+
+### `chainlesschain auth <action>`
+
+RBAC permission engine.
+
+```bash
+chainlesschain auth roles                          # List roles
+chainlesschain auth create-role <name>             # Create custom role
+chainlesschain auth grant <user> <role>            # Assign role
+chainlesschain auth check <user> <scope>           # Check permission
+chainlesschain auth permissions <user>             # List user permissions
+chainlesschain auth scopes                         # List all 26 scopes
+```
+
+### `chainlesschain audit <action>`
+
+Audit logging and compliance.
+
+```bash
+chainlesschain audit log                           # Recent events
+chainlesschain audit search --type security        # Search by type
+chainlesschain audit stats                         # Statistics
+chainlesschain audit export --format json          # Export logs
+chainlesschain audit purge --before 90             # Purge old logs
+chainlesschain audit types                         # List event types
+```
+
+---
+
+## Phase 5: P2P, Blockchain & Enterprise
+
+### `chainlesschain p2p <action>`
+
+Peer-to-peer messaging and device pairing.
+
+```bash
+chainlesschain p2p status                          # P2P network status
+chainlesschain p2p peers                           # List known peers
+chainlesschain p2p send <peer-id> "message"        # Send message
+chainlesschain p2p inbox                           # View inbox
+chainlesschain p2p pair <device-name>              # Pair a device
+chainlesschain p2p devices                         # List paired devices
+chainlesschain p2p unpair <device-id>              # Unpair a device
+```
+
+### `chainlesschain sync <action>`
+
+File and knowledge synchronization.
+
+```bash
+chainlesschain sync status                         # Sync status
+chainlesschain sync push                           # Push local changes
+chainlesschain sync pull                           # Pull remote changes
+chainlesschain sync conflicts                      # List conflicts
+chainlesschain sync resolve <id> --strategy local  # Resolve conflict
+chainlesschain sync log                            # Sync history
+chainlesschain sync clear                          # Clear sync state
+```
+
+### `chainlesschain wallet <action>`
+
+Digital wallet and asset management.
+
+```bash
+chainlesschain wallet create --name "My Wallet"    # Create wallet
+chainlesschain wallet list                         # List wallets
+chainlesschain wallet balance <address>            # Check balance
+chainlesschain wallet set-default <address>        # Set default wallet
+chainlesschain wallet delete <address>             # Delete wallet
+chainlesschain wallet asset <address> <type> <name> # Create asset
+chainlesschain wallet assets [address]             # List assets
+chainlesschain wallet transfer <asset-id> <to>     # Transfer asset
+chainlesschain wallet history [address]            # Transaction history
+chainlesschain wallet summary                      # Overall summary
+```
+
+### `chainlesschain org <action>`
+
+Organization management and workflows.
+
+```bash
+chainlesschain org create <name>                   # Create organization
+chainlesschain org list                            # List organizations
+chainlesschain org show <id>                       # Organization details
+chainlesschain org delete <id>                     # Delete organization
+chainlesschain org invite <org-id> <user-id>       # Invite member
+chainlesschain org members <org-id>                # List members
+chainlesschain org team-create <org-id> <name>     # Create team
+chainlesschain org teams <org-id>                  # List teams
+chainlesschain org approval-submit <org-id> <title> # Submit approval
+chainlesschain org approvals <org-id>              # List approvals
+chainlesschain org approve <request-id>            # Approve request
+chainlesschain org reject <request-id>             # Reject request
+```
+
+### `chainlesschain plugin <action>`
+
+Plugin marketplace management.
+
+```bash
+chainlesschain plugin list                         # List installed plugins
+chainlesschain plugin install <name> --version <v> # Install plugin
+chainlesschain plugin remove <name>                # Remove plugin
+chainlesschain plugin enable <name>                # Enable plugin
+chainlesschain plugin disable <name>               # Disable plugin
+chainlesschain plugin update <name> --version <v>  # Update plugin
+chainlesschain plugin info <name>                  # Plugin details
+chainlesschain plugin search <query>               # Search registry
+chainlesschain plugin registry                     # List all registry plugins
+chainlesschain plugin summary                      # Installation summary
+```
+
+---
+
 ## Global Options
 
 ```bash
@@ -240,13 +526,16 @@ Configuration is stored at `~/.chainlesschain/config.json`. The CLI creates and
 
 ### Supported LLM Providers
 
-| Provider            | Default Model | API Key Required |
-| ------------------- | ------------- | ---------------- |
-| Ollama (Local)      | qwen2:7b      | No               |
-| OpenAI              | gpt-4o        | Yes              |
-| DashScope (Alibaba) | qwen-max      | Yes              |
-| DeepSeek            | deepseek-chat | Yes              |
-| Custom              | —             | Yes              |
+| Provider            | Default Model     | API Key Required |
+| ------------------- | ----------------- | ---------------- |
+| Ollama (Local)      | qwen2:7b          | No               |
+| OpenAI              | gpt-4o            | Yes              |
+| Anthropic           | claude-sonnet-4-6 | Yes              |
+| DashScope (Alibaba) | qwen-max          | Yes              |
+| DeepSeek            | deepseek-chat     | Yes              |
+| Gemini (Google)     | gemini-pro        | Yes              |
+| Mistral             | mistral-large     | Yes              |
+| Custom              | —                 | Yes              |
 
 ## File Structure
 
@@ -265,22 +554,23 @@ Configuration is stored at `~/.chainlesschain/config.json`. The CLI creates and
 ```bash
 cd packages/cli
 npm install
-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)
+npm test                # Run all tests (903 tests across 47 files)
+npm run test:unit       # Unit tests only
+npm run test:integration # Integration tests
+npm run test:e2e        # End-to-end tests
 ```
 
 ### 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** |
+| Category                 | Files  | Tests   | Status          |
+| ------------------------ | ------ | ------- | --------------- |
+| Unit — lib modules       | 25     | 578     | All passing     |
+| Unit — commands          | 2      | 43      | All passing     |
+| Unit — runtime           | 1      | 6       | All passing     |
+| Integration              | 3      | 7       | All passing     |
+| E2E                      | 9      | 88      | All passing     |
+| Core packages (external) | —      | 118     | All passing     |
+| **CLI Total**            | **47** | **903** | **All passing** |
 
 ## License
 

package/bin/chainlesschain.js

@@ -1,5 +1,9 @@
 #!/usr/bin/env node
 
+// Ensure UTF-8 encoding on Windows to prevent Chinese character garbling (乱码)
+import { ensureUtf8 } from "../src/lib/ensure-utf8.js";
+ensureUtf8();
+
 import { createProgram } from "../src/index.js";
 
 const program = createProgram();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "chainlesschain",
-  "version": "0.37.9",
+  "version": "0.37.10",
   "description": "CLI for ChainlessChain - install, configure, and manage your personal AI management system",
   "type": "module",
   "bin": {

package/src/commands/audit.js

@@ -0,0 +1,286 @@
+/**
+ * Audit log commands
+ * chainlesschain audit log|search|stats|export|purge
+ */
+
+import chalk from "chalk";
+import fs from "fs";
+import { logger } from "../lib/logger.js";
+import { bootstrap, shutdown } from "../runtime/bootstrap.js";
+import {
+  getRecentEvents,
+  queryLogs,
+  getStatistics,
+  exportLogs,
+  purgeLogs,
+  EVENT_TYPES,
+  RISK_LEVELS,
+} from "../lib/audit-logger.js";
+
+const RISK_COLORS = {
+  low: chalk.gray,
+  medium: chalk.yellow,
+  high: chalk.red,
+  critical: chalk.bgRed.white,
+};
+
+function formatLogEntry(log) {
+  const riskColor = RISK_COLORS[log.risk_level] || chalk.gray;
+  const status = log.success ? chalk.green("OK") : chalk.red("FAIL");
+  const time = log.created_at || "";
+
+  return [
+    `  ${chalk.gray(log.id.slice(0, 8))} ${chalk.gray(time)}`,
+    `    ${chalk.cyan(log.event_type.padEnd(12))} ${chalk.white(log.operation)} ${status} ${riskColor(`[${log.risk_level}]`)}`,
+    log.actor ? `    ${chalk.gray("actor:")} ${log.actor}` : null,
+    log.target ? `    ${chalk.gray("target:")} ${log.target}` : null,
+    log.error_message
+      ? `    ${chalk.red("error:")} ${log.error_message}`
+      : null,
+  ]
+    .filter(Boolean)
+    .join("\n");
+}
+
+export function registerAuditCommand(program) {
+  const audit = program
+    .command("audit")
+    .description("Audit log — security event tracking and compliance");
+
+  // audit log (default)
+  audit
+    .command("log", { isDefault: true })
+    .description("Show recent audit events")
+    .option("-n, --limit <n>", "Number of events to show", "20")
+    .option("--type <type>", "Filter by event type")
+    .option("--risk <level>", "Filter by risk level")
+    .option("--json", "Output as JSON")
+    .action(async (options) => {
+      try {
+        const ctx = await bootstrap({ verbose: program.opts().verbose });
+        if (!ctx.db) {
+          logger.error("Database not available");
+          process.exit(1);
+        }
+        const db = ctx.db.getDatabase();
+
+        const filters = {
+          limit: parseInt(options.limit) || 20,
+        };
+        if (options.type) filters.eventType = options.type;
+        if (options.risk) filters.riskLevel = options.risk;
+
+        const logs = queryLogs(db, filters);
+
+        if (options.json) {
+          console.log(JSON.stringify(logs, null, 2));
+        } else if (logs.length === 0) {
+          logger.info("No audit events found");
+        } else {
+          logger.log(chalk.bold(`Audit Log (${logs.length} events):\n`));
+          for (const log of logs) {
+            logger.log(formatLogEntry(log));
+          }
+        }
+
+        await shutdown();
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  // audit search
+  audit
+    .command("search")
+    .description("Search audit logs")
+    .argument("<query>", "Search query")
+    .option("-n, --limit <n>", "Max results", "50")
+    .option("--type <type>", "Filter by event type")
+    .option("--risk <level>", "Filter by risk level")
+    .option("--from <date>", "Start date (ISO 8601)")
+    .option("--to <date>", "End date (ISO 8601)")
+    .option("--failures", "Show only failed events")
+    .option("--json", "Output as JSON")
+    .action(async (query, options) => {
+      try {
+        const ctx = await bootstrap({ verbose: program.opts().verbose });
+        if (!ctx.db) {
+          logger.error("Database not available");
+          process.exit(1);
+        }
+        const db = ctx.db.getDatabase();
+
+        const filters = {
+          search: query,
+          limit: parseInt(options.limit) || 50,
+        };
+        if (options.type) filters.eventType = options.type;
+        if (options.risk) filters.riskLevel = options.risk;
+        if (options.from) filters.startDate = options.from;
+        if (options.to) filters.endDate = options.to;
+        if (options.failures) filters.success = false;
+
+        const logs = queryLogs(db, filters);
+
+        if (options.json) {
+          console.log(JSON.stringify(logs, null, 2));
+        } else if (logs.length === 0) {
+          logger.info(`No audit events matching "${query}"`);
+        } else {
+          logger.log(chalk.bold(`Search Results (${logs.length}):\n`));
+          for (const log of logs) {
+            logger.log(formatLogEntry(log));
+          }
+        }
+
+        await shutdown();
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  // audit stats
+  audit
+    .command("stats")
+    .description("Show audit statistics")
+    .option("--from <date>", "Start date")
+    .option("--to <date>", "End date")
+    .option("--json", "Output as JSON")
+    .action(async (options) => {
+      try {
+        const ctx = await bootstrap({ verbose: program.opts().verbose });
+        if (!ctx.db) {
+          logger.error("Database not available");
+          process.exit(1);
+        }
+        const db = ctx.db.getDatabase();
+        const stats = getStatistics(db, options.from, options.to);
+
+        if (options.json) {
+          console.log(JSON.stringify(stats, null, 2));
+        } else {
+          logger.log(chalk.bold("Audit Statistics:\n"));
+          logger.log(`  ${chalk.bold("Total events:")}   ${stats.total}`);
+          logger.log(
+            `  ${chalk.bold("Failures:")}       ${chalk.red(stats.failures)}`,
+          );
+          logger.log(
+            `  ${chalk.bold("High risk:")}      ${chalk.red(stats.highRisk)}`,
+          );
+
+          if (Object.keys(stats.byEventType).length > 0) {
+            logger.log(`\n  ${chalk.bold("By Event Type:")}`);
+            for (const [type, count] of Object.entries(stats.byEventType)) {
+              logger.log(`    ${chalk.cyan(type.padEnd(15))} ${count}`);
+            }
+          }
+
+          if (Object.keys(stats.byRiskLevel).length > 0) {
+            logger.log(`\n  ${chalk.bold("By Risk Level:")}`);
+            for (const [level, count] of Object.entries(stats.byRiskLevel)) {
+              const color = RISK_COLORS[level] || chalk.gray;
+              logger.log(`    ${color(level.padEnd(15))} ${count}`);
+            }
+          }
+        }
+
+        await shutdown();
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  // audit export
+  audit
+    .command("export")
+    .description("Export audit logs to file")
+    .option("-o, --output <path>", "Output file path")
+    .option("-f, --format <fmt>", "Format: json or csv", "json")
+    .option("--from <date>", "Start date")
+    .option("--to <date>", "End date")
+    .option("-n, --limit <n>", "Max events", "10000")
+    .action(async (options) => {
+      try {
+        const ctx = await bootstrap({ verbose: program.opts().verbose });
+        if (!ctx.db) {
+          logger.error("Database not available");
+          process.exit(1);
+        }
+        const db = ctx.db.getDatabase();
+
+        const filters = { limit: parseInt(options.limit) || 10000 };
+        if (options.from) filters.startDate = options.from;
+        if (options.to) filters.endDate = options.to;
+
+        const data = exportLogs(db, options.format, filters);
+
+        if (options.output) {
+          fs.writeFileSync(options.output, data, "utf8");
+          logger.success(`Exported to ${options.output}`);
+        } else {
+          console.log(data);
+        }
+
+        await shutdown();
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  // audit purge
+  audit
+    .command("purge")
+    .description("Delete old audit logs")
+    .option("--days <n>", "Keep logs from last N days", "90")
+    .option("--force", "Skip confirmation")
+    .action(async (options) => {
+      try {
+        const days = parseInt(options.days) || 90;
+
+        if (!options.force) {
+          const { confirm } = await import("@inquirer/prompts");
+          const ok = await confirm({
+            message: `Delete audit logs older than ${days} days? This cannot be undone.`,
+          });
+          if (!ok) {
+            logger.info("Cancelled");
+            return;
+          }
+        }
+
+        const ctx = await bootstrap({ verbose: program.opts().verbose });
+        if (!ctx.db) {
+          logger.error("Database not available");
+          process.exit(1);
+        }
+        const db = ctx.db.getDatabase();
+        const deleted = purgeLogs(db, days);
+        logger.success(`Purged ${deleted} old audit events`);
+
+        await shutdown();
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  // audit types
+  audit
+    .command("types")
+    .description("List available event types and risk levels")
+    .action(async () => {
+      logger.log(chalk.bold("Event Types:\n"));
+      for (const [key, value] of Object.entries(EVENT_TYPES)) {
+        logger.log(`  ${chalk.cyan(value.padEnd(15))} ${chalk.gray(key)}`);
+      }
+      logger.log(chalk.bold("\nRisk Levels:\n"));
+      for (const [key, value] of Object.entries(RISK_LEVELS)) {
+        const color = RISK_COLORS[value] || chalk.gray;
+        logger.log(`  ${color(value.padEnd(15))} ${chalk.gray(key)}`);
+      }
+    });
+}