chainlesschain 0.37.8 → 0.37.10

package/src/commands/export.js

@@ -0,0 +1,125 @@
+/**
+ * Knowledge export commands
+ * chainlesschain export markdown|site --output <dir>
+ */
+
+import chalk from "chalk";
+import ora from "ora";
+import { resolve } from "path";
+import { logger } from "../lib/logger.js";
+import { bootstrap, shutdown } from "../runtime/bootstrap.js";
+import { exportToMarkdown, exportToSite } from "../lib/knowledge-exporter.js";
+
+export function registerExportCommand(program) {
+  const exp = program
+    .command("export")
+    .description("Export knowledge base to external formats");
+
+  // export markdown
+  exp
+    .command("markdown")
+    .description("Export notes as markdown files")
+    .requiredOption("-o, --output <dir>", "Output directory")
+    .option("--category <category>", "Filter by category")
+    .option("--tag <tag>", "Filter by tag")
+    .option("-n, --limit <n>", "Max notes to export")
+    .option("--json", "Output as JSON")
+    .action(async (options) => {
+      try {
+        const outputDir = resolve(options.output);
+        const spinner = ora("Exporting to markdown...").start();
+        const ctx = await bootstrap({ verbose: program.opts().verbose });
+        if (!ctx.db) {
+          spinner.fail("Database not available");
+          process.exit(1);
+        }
+
+        const db = ctx.db.getDatabase();
+        const exported = exportToMarkdown(db, outputDir, {
+          category: options.category,
+          tag: options.tag,
+          limit: options.limit ? parseInt(options.limit) : undefined,
+        });
+        spinner.stop();
+
+        if (options.json) {
+          console.log(
+            JSON.stringify(
+              { count: exported.length, output: outputDir, files: exported },
+              null,
+              2,
+            ),
+          );
+        } else if (exported.length === 0) {
+          logger.info("No notes to export");
+        } else {
+          logger.success(
+            `Exported ${chalk.cyan(exported.length)} notes to ${chalk.gray(outputDir)}`,
+          );
+          for (const f of exported.slice(0, 10)) {
+            logger.log(`  ${chalk.gray(f.path)}`);
+          }
+          if (exported.length > 10) {
+            logger.log(chalk.gray(`  ... and ${exported.length - 10} more`));
+          }
+        }
+
+        await shutdown();
+      } catch (err) {
+        logger.error(`Export failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  // export site
+  exp
+    .command("site")
+    .description("Export notes as a static HTML website")
+    .requiredOption("-o, --output <dir>", "Output directory")
+    .option("--title <title>", "Site title", "ChainlessChain Knowledge Base")
+    .option("--category <category>", "Filter by category")
+    .option("--tag <tag>", "Filter by tag")
+    .option("--json", "Output as JSON")
+    .action(async (options) => {
+      try {
+        const outputDir = resolve(options.output);
+        const spinner = ora("Generating static site...").start();
+        const ctx = await bootstrap({ verbose: program.opts().verbose });
+        if (!ctx.db) {
+          spinner.fail("Database not available");
+          process.exit(1);
+        }
+
+        const db = ctx.db.getDatabase();
+        const exported = exportToSite(db, outputDir, {
+          title: options.title,
+          category: options.category,
+          tag: options.tag,
+        });
+        spinner.stop();
+
+        if (options.json) {
+          console.log(
+            JSON.stringify(
+              { count: exported.length, output: outputDir, files: exported },
+              null,
+              2,
+            ),
+          );
+        } else {
+          logger.success(
+            `Generated static site with ${chalk.cyan(exported.length)} pages`,
+          );
+          logger.log(`  ${chalk.gray("Output:")} ${outputDir}`);
+          logger.log(
+            `  ${chalk.gray("Files:")} index.html, style.css, ${exported.length} note pages`,
+          );
+        }
+
+        await shutdown();
+      } catch (err) {
+        logger.error(`Export failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+}

package/src/commands/git.js

@@ -0,0 +1,215 @@
+/**
+ * Git integration commands
+ * chainlesschain git status|auto-commit|hooks|history-analyze
+ */
+
+import chalk from "chalk";
+import { resolve } from "path";
+import { logger } from "../lib/logger.js";
+import {
+  gitStatus,
+  gitAutoCommit,
+  gitLog,
+  gitHistoryAnalyze,
+  gitInit,
+  isGitRepo,
+} from "../lib/git-integration.js";
+
+export function registerGitCommand(program) {
+  const git = program
+    .command("git")
+    .description("Git integration for knowledge base versioning");
+
+  // git status
+  git
+    .command("status")
+    .description("Show git status of the knowledge base directory")
+    .option("-d, --dir <dir>", "Target directory", ".")
+    .option("--json", "Output as JSON")
+    .action(async (options) => {
+      try {
+        const dir = resolve(options.dir);
+        const status = gitStatus(dir);
+
+        if (options.json) {
+          console.log(JSON.stringify(status, null, 2));
+          return;
+        }
+
+        if (!status.isRepo) {
+          logger.info(
+            `Not a git repository: ${dir}\n  Run ${chalk.cyan("chainlesschain git init")} to initialize.`,
+          );
+          return;
+        }
+
+        logger.log(chalk.bold(`Branch: ${chalk.cyan(status.branch)}`));
+
+        if (status.clean) {
+          logger.log(chalk.green("Working tree clean"));
+        } else {
+          logger.log(`\n${status.files.length} changed file(s):\n`);
+          for (const f of status.files) {
+            const statusColor =
+              f.status === "M"
+                ? chalk.yellow
+                : f.status === "A" || f.status === "??"
+                  ? chalk.green
+                  : f.status === "D"
+                    ? chalk.red
+                    : chalk.white;
+            logger.log(`  ${statusColor(f.status.padEnd(3))} ${f.file}`);
+          }
+        }
+      } catch (err) {
+        logger.error(`Git status failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  // git init
+  git
+    .command("init")
+    .description("Initialize a git repository")
+    .option("-d, --dir <dir>", "Target directory", ".")
+    .action(async (options) => {
+      try {
+        const dir = resolve(options.dir);
+        const result = gitInit(dir);
+        if (result.initialized) {
+          logger.success(`Initialized git repository in ${chalk.gray(dir)}`);
+        } else {
+          logger.info(result.message);
+        }
+      } catch (err) {
+        logger.error(`Git init failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  // git auto-commit
+  git
+    .command("auto-commit")
+    .description("Auto-commit all changes with a generated message")
+    .option("-d, --dir <dir>", "Target directory", ".")
+    .option("-m, --message <msg>", "Custom commit message")
+    .option("--json", "Output as JSON")
+    .action(async (options) => {
+      try {
+        const dir = resolve(options.dir);
+        const result = gitAutoCommit(dir, options.message);
+
+        if (options.json) {
+          console.log(JSON.stringify(result, null, 2));
+          return;
+        }
+
+        if (!result.committed) {
+          logger.info(result.message);
+        } else {
+          logger.success(
+            `Committed ${chalk.cyan(result.hash)}: ${result.message}`,
+          );
+          logger.log(chalk.gray(`  ${result.filesChanged} file(s) changed`));
+        }
+      } catch (err) {
+        logger.error(`Auto-commit failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  // git hooks
+  git
+    .command("hooks")
+    .description("Install git hooks for the knowledge base")
+    .option("-d, --dir <dir>", "Target directory", ".")
+    .option("--install", "Install hooks")
+    .action(async (options) => {
+      try {
+        const dir = resolve(options.dir);
+
+        if (!isGitRepo(dir)) {
+          logger.error("Not a git repository. Run 'git init' first.");
+          process.exit(1);
+        }
+
+        if (options.install) {
+          const { installHooks } = await import("../lib/git-integration.js");
+          const result = installHooks(dir);
+          logger.success(
+            `Installed ${chalk.cyan(result.hook)} hook at ${chalk.gray(result.path)}`,
+          );
+        } else {
+          logger.info(`Use ${chalk.cyan("--install")} to install git hooks`);
+        }
+      } catch (err) {
+        logger.error(`Hooks failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  // git history-analyze
+  git
+    .command("history-analyze")
+    .description("Analyze repository history and statistics")
+    .option("-d, --dir <dir>", "Target directory", ".")
+    .option("-n, --limit <n>", "Recent commits to show", "10")
+    .option("--json", "Output as JSON")
+    .action(async (options) => {
+      try {
+        const dir = resolve(options.dir);
+
+        if (!isGitRepo(dir)) {
+          logger.error("Not a git repository");
+          process.exit(1);
+        }
+
+        const analysis = gitHistoryAnalyze(dir);
+        const recentLog = gitLog(dir, parseInt(options.limit));
+
+        if (options.json) {
+          console.log(
+            JSON.stringify({ ...analysis, recentCommits: recentLog }, null, 2),
+          );
+          return;
+        }
+
+        logger.log(chalk.bold("Repository Analysis\n"));
+        logger.log(
+          `  ${chalk.gray("Total commits:")} ${analysis.totalCommits}`,
+        );
+        logger.log(
+          `  ${chalk.gray("Tracked files:")} ${analysis.trackedFiles}`,
+        );
+        if (analysis.firstCommit) {
+          logger.log(
+            `  ${chalk.gray("First commit:")} ${analysis.firstCommit}`,
+          );
+        }
+        if (analysis.lastCommit) {
+          logger.log(`  ${chalk.gray("Last commit:")} ${analysis.lastCommit}`);
+        }
+
+        if (analysis.contributors.length > 0) {
+          logger.log(chalk.bold("\nContributors:\n"));
+          for (const c of analysis.contributors) {
+            logger.log(
+              `  ${chalk.cyan(c.commits.toString().padStart(4))} ${c.author}`,
+            );
+          }
+        }
+
+        if (recentLog.length > 0) {
+          logger.log(chalk.bold("\nRecent Commits:\n"));
+          for (const c of recentLog) {
+            logger.log(
+              `  ${chalk.yellow(c.shortHash)} ${chalk.white(c.subject)} ${chalk.gray(c.date)}`,
+            );
+          }
+        }
+      } catch (err) {
+        logger.error(`Analysis failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+}

package/src/commands/import.js

@@ -0,0 +1,259 @@
+/**
+ * Knowledge import commands
+ * chainlesschain import markdown|evernote|notion|pdf <path>
+ */
+
+import chalk from "chalk";
+import ora from "ora";
+import { existsSync, statSync } from "fs";
+import { resolve } from "path";
+import { logger } from "../lib/logger.js";
+import { bootstrap, shutdown } from "../runtime/bootstrap.js";
+import {
+  importMarkdownDir,
+  importEnexFile,
+  importNotionDir,
+} from "../lib/knowledge-importer.js";
+
+export function registerImportCommand(program) {
+  const imp = program
+    .command("import")
+    .description("Import knowledge from external sources");
+
+  // import markdown
+  imp
+    .command("markdown")
+    .description("Import markdown files from a directory")
+    .argument("<dir>", "Directory containing .md files")
+    .option("--json", "Output as JSON")
+    .action(async (dir, options) => {
+      try {
+        const absDir = resolve(dir);
+        if (!existsSync(absDir) || !statSync(absDir).isDirectory()) {
+          logger.error(`Directory not found: ${absDir}`);
+          process.exit(1);
+        }
+
+        const spinner = ora("Importing markdown files...").start();
+        const ctx = await bootstrap({ verbose: program.opts().verbose });
+        if (!ctx.db) {
+          spinner.fail("Database not available");
+          process.exit(1);
+        }
+
+        const db = ctx.db.getDatabase();
+        const imported = importMarkdownDir(db, absDir);
+        spinner.stop();
+
+        if (options.json) {
+          console.log(
+            JSON.stringify(
+              { count: imported.length, notes: imported },
+              null,
+              2,
+            ),
+          );
+        } else if (imported.length === 0) {
+          logger.info("No .md files found in the directory");
+        } else {
+          logger.success(
+            `Imported ${chalk.cyan(imported.length)} markdown notes`,
+          );
+          for (const n of imported.slice(0, 10)) {
+            logger.log(
+              `  ${chalk.gray(n.id.slice(0, 8))}  ${chalk.white(n.title)}  ${chalk.gray(n.source || "")}`,
+            );
+          }
+          if (imported.length > 10) {
+            logger.log(chalk.gray(`  ... and ${imported.length - 10} more`));
+          }
+        }
+
+        await shutdown();
+      } catch (err) {
+        logger.error(`Import failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  // import evernote
+  imp
+    .command("evernote")
+    .description("Import from Evernote ENEX export file")
+    .argument("<file>", "Path to .enex file")
+    .option("--json", "Output as JSON")
+    .action(async (file, options) => {
+      try {
+        const absFile = resolve(file);
+        if (!existsSync(absFile)) {
+          logger.error(`File not found: ${absFile}`);
+          process.exit(1);
+        }
+
+        const spinner = ora("Importing Evernote notes...").start();
+        const ctx = await bootstrap({ verbose: program.opts().verbose });
+        if (!ctx.db) {
+          spinner.fail("Database not available");
+          process.exit(1);
+        }
+
+        const db = ctx.db.getDatabase();
+        const imported = importEnexFile(db, absFile);
+        spinner.stop();
+
+        if (options.json) {
+          console.log(
+            JSON.stringify(
+              { count: imported.length, notes: imported },
+              null,
+              2,
+            ),
+          );
+        } else if (imported.length === 0) {
+          logger.info("No notes found in the ENEX file");
+        } else {
+          logger.success(
+            `Imported ${chalk.cyan(imported.length)} Evernote notes`,
+          );
+          for (const n of imported.slice(0, 10)) {
+            const tags =
+              n.tags.length > 0 ? chalk.gray(` [${n.tags.join(", ")}]`) : "";
+            logger.log(
+              `  ${chalk.gray(n.id.slice(0, 8))}  ${chalk.white(n.title)}${tags}`,
+            );
+          }
+          if (imported.length > 10) {
+            logger.log(chalk.gray(`  ... and ${imported.length - 10} more`));
+          }
+        }
+
+        await shutdown();
+      } catch (err) {
+        logger.error(`Import failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  // import notion
+  imp
+    .command("notion")
+    .description("Import from Notion export directory")
+    .argument("<dir>", "Notion export directory")
+    .option("--json", "Output as JSON")
+    .action(async (dir, options) => {
+      try {
+        const absDir = resolve(dir);
+        if (!existsSync(absDir) || !statSync(absDir).isDirectory()) {
+          logger.error(`Directory not found: ${absDir}`);
+          process.exit(1);
+        }
+
+        const spinner = ora("Importing Notion pages...").start();
+        const ctx = await bootstrap({ verbose: program.opts().verbose });
+        if (!ctx.db) {
+          spinner.fail("Database not available");
+          process.exit(1);
+        }
+
+        const db = ctx.db.getDatabase();
+        const imported = importNotionDir(db, absDir);
+        spinner.stop();
+
+        if (options.json) {
+          console.log(
+            JSON.stringify(
+              { count: imported.length, notes: imported },
+              null,
+              2,
+            ),
+          );
+        } else if (imported.length === 0) {
+          logger.info("No markdown pages found in Notion export");
+        } else {
+          logger.success(
+            `Imported ${chalk.cyan(imported.length)} Notion pages`,
+          );
+          for (const n of imported.slice(0, 10)) {
+            const tags =
+              n.tags.length > 0 ? chalk.gray(` [${n.tags.join(", ")}]`) : "";
+            logger.log(
+              `  ${chalk.gray(n.id.slice(0, 8))}  ${chalk.white(n.title)}${tags}`,
+            );
+          }
+          if (imported.length > 10) {
+            logger.log(chalk.gray(`  ... and ${imported.length - 10} more`));
+          }
+        }
+
+        await shutdown();
+      } catch (err) {
+        logger.error(`Import failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  // import pdf
+  imp
+    .command("pdf")
+    .description("Import text from a PDF file")
+    .argument("<file>", "Path to .pdf file")
+    .option("--json", "Output as JSON")
+    .action(async (file, options) => {
+      try {
+        const absFile = resolve(file);
+        if (!existsSync(absFile)) {
+          logger.error(`File not found: ${absFile}`);
+          process.exit(1);
+        }
+
+        const spinner = ora("Extracting text from PDF...").start();
+        const ctx = await bootstrap({ verbose: program.opts().verbose });
+        if (!ctx.db) {
+          spinner.fail("Database not available");
+          process.exit(1);
+        }
+
+        const db = ctx.db.getDatabase();
+
+        // Lazy-load pdf-parser to keep it optional
+        const { parsePdfText } = await import("../lib/pdf-parser.js");
+        const { insertNote, ensureNotesTable } =
+          await import("../lib/knowledge-importer.js");
+        ensureNotesTable(db);
+
+        const parsed = await parsePdfText(absFile);
+        spinner.stop();
+
+        if (!parsed.content || parsed.content.trim().length === 0) {
+          logger.info("No text could be extracted from the PDF");
+          await shutdown();
+          return;
+        }
+
+        const note = insertNote(db, {
+          title: parsed.title,
+          content: parsed.content,
+          tags: ["pdf"],
+          category: "pdf",
+        });
+
+        if (options.json) {
+          console.log(JSON.stringify(note, null, 2));
+        } else {
+          logger.success(`Imported PDF as note: ${chalk.cyan(parsed.title)}`);
+          logger.log(`  ${chalk.gray("ID:")} ${note.id.slice(0, 8)}`);
+          logger.log(
+            `  ${chalk.gray("Length:")} ${parsed.content.length} chars`,
+          );
+          if (parsed.pages) {
+            logger.log(`  ${chalk.gray("Pages:")} ${parsed.pages}`);
+          }
+        }
+
+        await shutdown();
+      } catch (err) {
+        logger.error(`PDF import failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+}