chainlesschain 0.37.9 → 0.37.11

package/src/commands/sync.js

@@ -0,0 +1,249 @@
+/**
+ * Sync commands
+ * chainlesschain sync status|push|pull|conflicts|resolve|log|clear
+ */
+
+import chalk from "chalk";
+import { logger } from "../lib/logger.js";
+import { bootstrap, shutdown } from "../runtime/bootstrap.js";
+import {
+  getSyncStatus,
+  pushResources,
+  pullResources,
+  getConflicts,
+  resolveConflict,
+  getSyncLog,
+  clearSyncData,
+  registerResource,
+  getAllSyncStates,
+} from "../lib/sync-manager.js";
+
+export function registerSyncCommand(program) {
+  const sync = program
+    .command("sync")
+    .description("File and knowledge synchronization");
+
+  // sync status
+  sync
+    .command("status", { isDefault: true })
+    .description("Show sync status")
+    .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 status = getSyncStatus(db);
+
+        if (options.json) {
+          console.log(JSON.stringify(status, null, 2));
+        } else {
+          logger.log(chalk.bold("Sync Status:\n"));
+          logger.log(`  ${chalk.bold("Resources:")}  ${status.totalResources}`);
+          logger.log(
+            `  ${chalk.bold("Pending:")}    ${chalk.yellow(status.pending)}`,
+          );
+          logger.log(
+            `  ${chalk.bold("Synced:")}     ${chalk.green(status.synced)}`,
+          );
+          logger.log(
+            `  ${chalk.bold("Conflicts:")}  ${status.conflicts > 0 ? chalk.red(status.conflicts) : "0"}`,
+          );
+        }
+
+        await shutdown();
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  // sync push
+  sync
+    .command("push")
+    .description("Push local changes to remote")
+    .option("--type <type>", "Resource type to push")
+    .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 result = pushResources(db, options.type);
+        logger.success(`Pushed ${result.pushed}/${result.total} resources`);
+        await shutdown();
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  // sync pull
+  sync
+    .command("pull")
+    .description("Pull remote changes to local")
+    .option("--type <type>", "Resource type to pull")
+    .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 result = pullResources(db, options.type);
+        logger.success(
+          `Checked ${result.checked} resources, updated ${result.updated}`,
+        );
+        await shutdown();
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  // sync conflicts
+  sync
+    .command("conflicts")
+    .description("Show sync conflicts")
+    .option("--all", "Include resolved conflicts")
+    .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 conflicts = getConflicts(db, { resolved: options.all });
+
+        if (options.json) {
+          console.log(JSON.stringify(conflicts, null, 2));
+        } else if (conflicts.length === 0) {
+          logger.info("No conflicts");
+        } else {
+          logger.log(chalk.bold(`Conflicts (${conflicts.length}):\n`));
+          for (const c of conflicts) {
+            const resolved = c.resolution
+              ? chalk.green("[resolved]")
+              : chalk.red("[unresolved]");
+            logger.log(`  ${chalk.cyan(c.id)} ${resolved}`);
+            logger.log(
+              `    ${chalk.gray(`${c.resource_type}/${c.resource_id}`)}`,
+            );
+          }
+        }
+
+        await shutdown();
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  // sync resolve
+  sync
+    .command("resolve")
+    .description("Resolve a sync conflict")
+    .argument("<conflict-id>", "Conflict ID")
+    .option("--use <side>", "Use local or remote version", "local")
+    .action(async (conflictId, 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 ok = resolveConflict(db, conflictId, options.use);
+
+        if (ok) {
+          logger.success(`Conflict resolved (${options.use})`);
+        } else {
+          logger.error(`Conflict not found: ${conflictId}`);
+        }
+
+        await shutdown();
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  // sync log
+  sync
+    .command("log")
+    .description("Show sync operation log")
+    .option("--limit <n>", "Number of entries", "20")
+    .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 entries = getSyncLog(db, { limit: parseInt(options.limit) });
+
+        if (options.json) {
+          console.log(JSON.stringify(entries, null, 2));
+        } else if (entries.length === 0) {
+          logger.info("No sync log entries");
+        } else {
+          logger.log(chalk.bold(`Sync Log (${entries.length}):\n`));
+          for (const e of entries) {
+            const statusColor =
+              e.status === "success" ? chalk.green : chalk.red;
+            logger.log(
+              `  ${chalk.gray(e.created_at)} ${chalk.bold(e.operation)} ${statusColor(e.status)}`,
+            );
+          }
+        }
+
+        await shutdown();
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  // sync clear
+  sync
+    .command("clear")
+    .description("Clear all sync data")
+    .option("--force", "Skip confirmation")
+    .action(async (options) => {
+      try {
+        if (!options.force) {
+          const { confirm } = await import("@inquirer/prompts");
+          const ok = await confirm({
+            message: "Clear all sync data? 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();
+        clearSyncData(db);
+        logger.success("Sync data cleared");
+        await shutdown();
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+}

package/src/commands/tokens.js

@@ -0,0 +1,214 @@
+/**
+ * Token usage tracking commands
+ * chainlesschain tokens [show|breakdown|recent|reset]
+ */
+
+import chalk from "chalk";
+import { logger } from "../lib/logger.js";
+import { bootstrap, shutdown } from "../runtime/bootstrap.js";
+import {
+  getUsageStats,
+  getTodayStats,
+  getCostBreakdown,
+  getRecentUsage,
+} from "../lib/token-tracker.js";
+import {
+  getCacheStats,
+  clearCache,
+  clearExpired,
+} from "../lib/response-cache.js";
+
+export function registerTokensCommand(program) {
+  const tokens = program
+    .command("tokens")
+    .description("LLM token usage tracking and response cache");
+
+  // tokens show (default)
+  tokens
+    .command("show", { isDefault: true })
+    .description("Show token usage summary")
+    .option("--period <period>", "Time period: today, week, month, all", "all")
+    .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();
+
+        let statsOptions = {};
+        const now = new Date();
+        if (options.period === "today") {
+          statsOptions.startDate = now.toISOString().slice(0, 10);
+        } else if (options.period === "week") {
+          const weekAgo = new Date(now - 7 * 24 * 60 * 60 * 1000);
+          statsOptions.startDate = weekAgo.toISOString().slice(0, 10);
+        } else if (options.period === "month") {
+          const monthAgo = new Date(now - 30 * 24 * 60 * 60 * 1000);
+          statsOptions.startDate = monthAgo.toISOString().slice(0, 10);
+        }
+
+        const stats = getUsageStats(db, statsOptions);
+        const todayStats = getTodayStats(db);
+
+        if (options.json) {
+          console.log(JSON.stringify({ stats, today: todayStats }, null, 2));
+        } else {
+          logger.log(chalk.bold(`Token Usage (${options.period}):\n`));
+          logger.log(`  Total calls:      ${chalk.cyan(stats.total_calls)}`);
+          logger.log(
+            `  Input tokens:     ${chalk.cyan(stats.total_input_tokens.toLocaleString())}`,
+          );
+          logger.log(
+            `  Output tokens:    ${chalk.cyan(stats.total_output_tokens.toLocaleString())}`,
+          );
+          logger.log(
+            `  Total tokens:     ${chalk.cyan(stats.total_tokens.toLocaleString())}`,
+          );
+          logger.log(
+            `  Total cost:       ${chalk.yellow("$" + stats.total_cost_usd.toFixed(4))}`,
+          );
+          logger.log(
+            `  Avg response:     ${chalk.gray(Math.round(stats.avg_response_time_ms) + "ms")}`,
+          );
+
+          if (options.period !== "today") {
+            logger.log(chalk.bold("\n  Today:"));
+            logger.log(
+              `    Calls: ${chalk.cyan(todayStats.total_calls)}  Tokens: ${chalk.cyan(todayStats.total_tokens.toLocaleString())}  Cost: ${chalk.yellow("$" + todayStats.total_cost_usd.toFixed(4))}`,
+            );
+          }
+        }
+
+        await shutdown();
+      } catch (err) {
+        logger.error(`Failed to get token stats: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  // tokens breakdown
+  tokens
+    .command("breakdown")
+    .description("Show cost breakdown by provider/model")
+    .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 breakdown = getCostBreakdown(db);
+
+        if (options.json) {
+          console.log(JSON.stringify(breakdown, null, 2));
+        } else if (breakdown.length === 0) {
+          logger.info("No usage data yet");
+        } else {
+          logger.log(chalk.bold("Cost Breakdown:\n"));
+          for (const row of breakdown) {
+            logger.log(
+              `  ${chalk.cyan(row.provider)}/${chalk.white(row.model)}`,
+            );
+            logger.log(
+              `    Calls: ${row.calls}  Tokens: ${row.total_tokens.toLocaleString()}  Cost: ${chalk.yellow("$" + row.cost_usd.toFixed(4))}`,
+            );
+          }
+        }
+
+        await shutdown();
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  // tokens recent
+  tokens
+    .command("recent")
+    .description("Show recent LLM calls")
+    .option("-n, --limit <n>", "Number of entries", "10")
+    .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 entries = getRecentUsage(
+          db,
+          Math.max(1, parseInt(options.limit) || 10),
+        );
+
+        if (options.json) {
+          console.log(JSON.stringify(entries, null, 2));
+        } else if (entries.length === 0) {
+          logger.info("No recent usage");
+        } else {
+          logger.log(chalk.bold("Recent LLM Calls:\n"));
+          for (const e of entries) {
+            logger.log(
+              `  ${chalk.gray(e.created_at)}  ${chalk.cyan(e.provider)}/${chalk.white(e.model)}  ${e.total_tokens} tokens  ${chalk.yellow("$" + e.cost_usd.toFixed(4))}  ${chalk.gray(e.response_time_ms + "ms")}`,
+            );
+          }
+        }
+
+        await shutdown();
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  // tokens cache
+  tokens
+    .command("cache")
+    .description("Show response cache statistics")
+    .option("--clear", "Clear all cached responses")
+    .option("--cleanup", "Remove expired entries only")
+    .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();
+
+        if (options.clear) {
+          clearCache(db);
+          logger.success("Response cache cleared");
+        } else if (options.cleanup) {
+          const removed = clearExpired(db);
+          logger.success(`Removed ${removed} expired cache entries`);
+        } else {
+          const stats = getCacheStats(db);
+          if (options.json) {
+            console.log(JSON.stringify(stats, null, 2));
+          } else {
+            logger.log(chalk.bold("Response Cache:\n"));
+            logger.log(`  Entries:        ${chalk.cyan(stats.total_entries)}`);
+            logger.log(`  Total hits:     ${chalk.cyan(stats.total_hits)}`);
+            logger.log(
+              `  Tokens saved:   ${chalk.green(stats.total_tokens_saved.toLocaleString())}`,
+            );
+            logger.log(
+              `  Expired:        ${chalk.gray(stats.expired_entries)}`,
+            );
+          }
+        }
+
+        await shutdown();
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+}