@datacore-one/cli 1.0.2 → 1.0.3

package/dist/index.js

@@ -8650,6 +8650,150 @@ function startOperation(operation, params = {}) {
   return new Operation(operation, params);
 }
 
+// src/lib/animation.ts
+var SPINNER_FRAMES = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
+var MATRIX_CHARS = "ｱｲｳｴｵｶｷｸｹｺｻｼｽｾｿﾀﾁﾂﾃﾄﾅﾆﾇﾈﾉﾊﾋﾌﾍﾎﾏﾐﾑﾒﾓﾔﾕﾖﾗﾘﾙﾚﾛﾜﾝ0123456789";
+var c = {
+  reset: "\x1B[0m",
+  bright: "\x1B[1m",
+  dim: "\x1B[2m",
+  green: "\x1B[32m",
+  cyan: "\x1B[36m",
+  yellow: "\x1B[33m",
+  magenta: "\x1B[35m",
+  blue: "\x1B[34m",
+  gray: "\x1B[90m"
+};
+var BANNER = `
+${c.cyan}${c.bright}
+    ██████╗  █████╗ ████████╗ █████╗  ██████╗ ██████╗ ██████╗ ███████╗
+    ██╔══██╗██╔══██╗╚══██╔══╝██╔══██╗██╔════╝██╔═══██╗██╔══██╗██╔════╝
+    ██║  ██║███████║   ██║   ███████║██║     ██║   ██║██████╔╝█████╗
+    ██║  ██║██╔══██║   ██║   ██╔══██║██║     ██║   ██║██╔══██╗██╔══╝
+    ██████╔╝██║  ██║   ██║   ██║  ██║╚██████╗╚██████╔╝██║  ██║███████╗
+    ╚═════╝ ╚═╝  ╚═╝   ╚═╝   ╚═╝  ╚═╝ ╚═════╝ ╚═════╝ ╚═╝  ╚═╝╚══════╝
+${c.reset}${c.dim}                    AI-Powered Second Brain ${c.reset}
+`;
+var INIT_COMPLETE = `
+${c.green}${c.bright}
+    ╔═══════════════════════════════════════════════════════════════╗
+    ║                                                               ║
+    ║   ${c.reset}${c.green}█████╗  ██████╗████████╗██╗██╗   ██╗███████╗${c.bright}                ║
+    ║   ${c.reset}${c.green}██╔══██╗██╔════╝╚══██╔══╝██║██║   ██║██╔════╝${c.bright}                ║
+    ║   ${c.reset}${c.green}███████║██║        ██║   ██║██║   ██║█████╗${c.bright}                  ║
+    ║   ${c.reset}${c.green}██╔══██║██║        ██║   ██║╚██╗ ██╔╝██╔══╝${c.bright}                  ║
+    ║   ${c.reset}${c.green}██║  ██║╚██████╗   ██║   ██║ ╚████╔╝ ███████╗${c.bright}                ║
+    ║   ${c.reset}${c.green}╚═╝  ╚═╝ ╚═════╝   ╚═╝   ╚═╝  ╚═══╝  ╚══════╝${c.bright}                ║
+    ║                                                               ║
+    ╚═══════════════════════════════════════════════════════════════╝
+${c.reset}
+`;
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+async function typewrite(text, speed = 30) {
+  for (const char of text) {
+    process.stdout.write(char);
+    await sleep(speed);
+  }
+  console.log();
+}
+class Spinner {
+  interval = null;
+  frame = 0;
+  message;
+  constructor(message) {
+    this.message = message;
+  }
+  start() {
+    process.stdout.write("\x1B[?25l");
+    this.interval = setInterval(() => {
+      const spinner = SPINNER_FRAMES[this.frame % SPINNER_FRAMES.length];
+      process.stdout.write(`\r${c.cyan}${spinner}${c.reset} ${this.message}`);
+      this.frame++;
+    }, 80);
+  }
+  update(message) {
+    this.message = message;
+  }
+  succeed(message) {
+    this.stop();
+    console.log(`\r${c.green}✓${c.reset} ${message || this.message}`);
+  }
+  fail(message) {
+    this.stop();
+    console.log(`\r${c.yellow}✗${c.reset} ${message || this.message}`);
+  }
+  stop() {
+    if (this.interval) {
+      clearInterval(this.interval);
+      this.interval = null;
+    }
+    process.stdout.write("\x1B[?25h");
+    process.stdout.write("\r" + " ".repeat(this.message.length + 10) + "\r");
+  }
+}
+function step(num, total, message) {
+  console.log(`${c.dim}[${num}/${total}]${c.reset} ${message}`);
+}
+function section(title) {
+  console.log();
+  console.log(`${c.cyan}${c.bright}▸ ${title}${c.reset}`);
+  console.log(`${c.dim}${"─".repeat(50)}${c.reset}`);
+}
+async function matrixRain(duration = 500) {
+  const cols = process.stdout.columns || 80;
+  const rows = 3;
+  const drops = Array(cols).fill(0).map(() => Math.floor(Math.random() * rows));
+  const startTime = Date.now();
+  while (Date.now() - startTime < duration) {
+    let frame = "";
+    for (let y = 0;y < rows; y++) {
+      for (let x = 0;x < cols; x++) {
+        const drop = drops[x] ?? 0;
+        if (drop === y) {
+          frame += `${c.green}${c.bright}${MATRIX_CHARS[Math.floor(Math.random() * MATRIX_CHARS.length)]}${c.reset}`;
+        } else if (drop === y - 1) {
+          frame += `${c.green}${MATRIX_CHARS[Math.floor(Math.random() * MATRIX_CHARS.length)]}${c.reset}`;
+        } else {
+          frame += " ";
+        }
+      }
+      frame += `
+`;
+    }
+    process.stdout.write(frame);
+    for (let i = 0;i < drops.length; i++) {
+      if (Math.random() > 0.9)
+        drops[i] = 0;
+      else
+        drops[i] = (drops[i] ?? 0) + 1;
+    }
+    await sleep(50);
+    process.stdout.write(`\x1B[${rows}A`);
+  }
+  for (let y = 0;y < rows; y++) {
+    console.log(" ".repeat(cols));
+  }
+  process.stdout.write(`\x1B[${rows}A`);
+}
+async function bootSequence() {
+  const lines = [
+    "Initializing neural pathways...",
+    "Loading cognitive frameworks...",
+    "Establishing knowledge graph...",
+    "Calibrating AI agents...",
+    "Synchronizing memory banks..."
+  ];
+  for (const line of lines) {
+    process.stdout.write(`${c.dim}> ${line}${c.reset}`);
+    await sleep(100 + Math.random() * 200);
+    process.stdout.write(` ${c.green}OK${c.reset}
+`);
+    await sleep(50);
+  }
+}
+
 // src/lib/init.ts
 var DATA_DIR4 = join6(process.env.HOME || "~", "Data");
 var DATACORE_DIR = join6(DATA_DIR4, ".datacore");
@@ -8658,6 +8802,7 @@ function isInitialized() {
 }
 async function initDatacore(options = {}) {
   const { nonInteractive = false, skipChecks = false, stream = false } = options;
+  const isTTY = stream && process.stdout.isTTY;
   const result = {
     success: false,
     created: [],
@@ -8665,19 +8810,32 @@ async function initDatacore(options = {}) {
     errors: [],
     nextSteps: []
   };
-  const log = (msg) => {
-    if (stream)
-      console.log(msg);
-  };
   const op = startOperation("init", { options });
   op.start();
   try {
+    if (isTTY) {
+      console.clear();
+      console.log(BANNER);
+      await sleep(500);
+      await matrixRain(400);
+      await bootSequence();
+      await sleep(300);
+    }
+    const TOTAL_STEPS = 6;
     op.addStep("check_dependencies");
     op.startStep("check_dependencies");
     if (!skipChecks) {
-      log("Checking dependencies...");
+      let spinner = null;
+      if (isTTY) {
+        section("System Check");
+        spinner = new Spinner("Scanning system dependencies...");
+        spinner.start();
+        await sleep(800);
+      }
       const doctor = runDoctor();
       if (doctor.status === "missing_required") {
+        if (spinner)
+          spinner.fail("Missing required dependencies");
         const missing = doctor.dependencies.filter((d) => d.required && !d.installed);
         for (const dep of missing) {
           result.errors.push(`Missing required dependency: ${dep.name}`);
@@ -8689,44 +8847,77 @@ async function initDatacore(options = {}) {
         op.fail("Missing required dependencies");
         return result;
       }
+      if (spinner) {
+        spinner.succeed(`Found ${doctor.dependencies.filter((d) => d.installed).length} dependencies`);
+      }
       if (doctor.status === "missing_recommended") {
         const missing = doctor.dependencies.filter((d) => !d.required && !d.installed);
         for (const dep of missing) {
           result.warnings.push(`Missing recommended: ${dep.name}`);
         }
       }
+      if (isTTY) {
+        for (const dep of doctor.dependencies) {
+          if (dep.installed) {
+            console.log(`  \x1B[32m✓\x1B[0m ${dep.name} ${dep.version ? `\x1B[90m(${dep.version})\x1B[0m` : ""}`);
+          } else {
+            console.log(`  \x1B[33m○\x1B[0m ${dep.name} \x1B[90m(not installed)\x1B[0m`);
+          }
+          await sleep(100);
+        }
+      }
     }
     op.completeStep("check_dependencies");
     op.addStep("create_data_dir");
     op.startStep("create_data_dir");
+    if (isTTY) {
+      section("Creating Brain Structure");
+    }
     if (!existsSync6(DATA_DIR4)) {
-      log(`Creating ${DATA_DIR4}...`);
+      if (isTTY) {
+        step(1, TOTAL_STEPS, "Allocating neural storage...");
+        await sleep(300);
+      }
       mkdirSync4(DATA_DIR4, { recursive: true });
       result.created.push(DATA_DIR4);
+      if (isTTY)
+        console.log(`  \x1B[32m→\x1B[0m ${DATA_DIR4}`);
+    } else if (isTTY) {
+      step(1, TOTAL_STEPS, "Neural storage exists");
     }
     op.completeStep("create_data_dir");
     op.addStep("create_datacore_dir");
     op.startStep("create_datacore_dir");
     if (!existsSync6(DATACORE_DIR)) {
-      log("Creating .datacore configuration...");
+      if (isTTY) {
+        step(2, TOTAL_STEPS, "Building core matrix...");
+      }
       const dirs = [
-        "",
-        "commands",
-        "agents",
-        "modules",
-        "specs",
-        "lib",
-        "env",
-        "state",
-        "registry"
+        { path: "", label: "core" },
+        { path: "commands", label: "commands" },
+        { path: "agents", label: "agents" },
+        { path: "modules", label: "modules" },
+        { path: "specs", label: "specs" },
+        { path: "lib", label: "lib" },
+        { path: "env", label: "env" },
+        { path: "state", label: "state" },
+        { path: "registry", label: "registry" }
       ];
-      for (const dir of dirs) {
+      for (const { path: dir, label } of dirs) {
         const path = join6(DATACORE_DIR, dir);
         if (!existsSync6(path)) {
           mkdirSync4(path, { recursive: true });
           result.created.push(path);
+          if (isTTY) {
+            console.log(`  \x1B[36m◆\x1B[0m ${label}`);
+            await sleep(80);
+          }
         }
       }
+      if (isTTY) {
+        step(3, TOTAL_STEPS, "Configuring neural pathways...");
+        await sleep(200);
+      }
       writeFileSync4(join6(DATACORE_DIR, "settings.yaml"), `# Datacore Settings
 # Override in settings.local.yaml
 
@@ -8758,32 +8949,51 @@ agents: []
 commands: []
 `);
       result.created.push(join6(DATACORE_DIR, "registry", "commands.yaml"));
+      if (isTTY)
+        console.log(`  \x1B[32m✓\x1B[0m Configuration loaded`);
+    } else if (isTTY) {
+      step(2, TOTAL_STEPS, "Core matrix exists");
+      step(3, TOTAL_STEPS, "Configuration loaded");
     }
     op.completeStep("create_datacore_dir");
     op.addStep("create_personal_space");
     op.startStep("create_personal_space");
     const spaces = listSpaces();
     if (spaces.length === 0) {
-      log("Creating personal space...");
+      if (isTTY) {
+        step(4, TOTAL_STEPS, "Spawning personal consciousness...");
+        await sleep(400);
+      }
       try {
         const space = createSpace("personal", "personal");
         result.created.push(space.path);
+        if (isTTY)
+          console.log(`  \x1B[35m◉\x1B[0m 0-personal initialized`);
       } catch (err) {
         result.warnings.push(`Could not create personal space: ${err.message}`);
       }
+    } else if (isTTY) {
+      step(4, TOTAL_STEPS, `Found ${spaces.length} existing space(s)`);
     }
     op.completeStep("create_personal_space");
     op.addStep("create_claude_symlink");
     op.startStep("create_claude_symlink");
     const claudeDir = join6(DATA_DIR4, ".claude");
     if (!existsSync6(claudeDir)) {
-      log("Creating .claude symlink...");
+      if (isTTY) {
+        step(5, TOTAL_STEPS, "Establishing AI link...");
+        await sleep(300);
+      }
       try {
         symlinkSync(DATACORE_DIR, claudeDir);
         result.created.push(claudeDir);
+        if (isTTY)
+          console.log(`  \x1B[32m⚡\x1B[0m Claude Code connected`);
       } catch {
         result.warnings.push("Could not create .claude symlink");
       }
+    } else if (isTTY) {
+      step(5, TOTAL_STEPS, "AI link established");
     }
     op.completeStep("create_claude_symlink");
     op.addStep("create_claude_md");
@@ -8791,44 +9001,56 @@ commands: []
     const claudeMd = join6(DATA_DIR4, "CLAUDE.md");
     const claudeBaseMd = join6(DATA_DIR4, "CLAUDE.base.md");
     if (!existsSync6(claudeMd) && !existsSync6(claudeBaseMd)) {
-      log("Creating CLAUDE.md...");
+      if (isTTY) {
+        step(6, TOTAL_STEPS, "Writing consciousness manifest...");
+        await sleep(300);
+      }
       writeFileSync4(claudeBaseMd, `# Datacore
 
 AI-powered second brain built on GTD methodology.
 
-## Getting Started
+## Quick Start
 
-Run \`datacore tour\` for an interactive walkthrough.
+\`\`\`bash
+cd ~/Data && claude
+\`\`\`
 
-## Quick Commands
+## Commands
 
 - \`datacore today\` - Daily briefing
 - \`datacore tomorrow\` - End-of-day wrap-up
 - \`datacore sync\` - Sync all repos
-
-## Documentation
-
-- \`datacore docs\` - Open documentation
 - \`datacore doctor\` - Check system health
 
 ## Spaces
 
 ${listSpaces().map((s) => `- ${s.name}`).join(`
-`) || "- (no spaces yet)"}
+`) || "- 0-personal"}
 
-## More Info
+## Documentation
 
 See .datacore/specs/ for detailed documentation.
 `);
       result.created.push(claudeBaseMd);
+      if (isTTY)
+        console.log(`  \x1B[32m✓\x1B[0m CLAUDE.md created`);
+    } else if (isTTY) {
+      step(6, TOTAL_STEPS, "Consciousness manifest exists");
     }
     op.completeStep("create_claude_md");
     result.success = true;
     result.nextSteps = [
-      "Run `datacore tour` for a guided walkthrough",
       "Run `datacore doctor` to verify your setup",
       "Start working: `cd ~/Data && claude`"
     ];
+    if (isTTY) {
+      await sleep(500);
+      console.log(INIT_COMPLETE);
+      await typewrite("  Your second brain is ready.", 25);
+      console.log();
+      console.log("  \x1B[90mNext:\x1B[0m cd ~/Data && claude");
+      console.log();
+    }
     op.complete();
   } catch (err) {
     result.errors.push(err.message);
@@ -8980,7 +9202,7 @@ import { execSync as execSync5 } from "child_process";
 import { join as join8 } from "path";
 var DATA_DIR6 = join8(process.env.HOME || "~", "Data");
 var LOCK_FILE = join8(DATA_DIR6, "datacore.lock.yaml");
-var CLI_VERSION = "1.0.0";
+var CLI_VERSION = "1.0.3";
 function getGitInfo(path) {
   if (!existsSync8(join8(path, ".git"))) {
     return {};
@@ -9199,7 +9421,7 @@ function restoreFromSnapshot(snapshot, options = {}) {
 }
 
 // src/index.ts
-var VERSION = "1.0.2";
+var VERSION = "1.0.3";
 var args = process.argv.slice(2);
 var parsed = parseArgs(args);
 async function handleMeta(command, cmdArgs, flags, format) {
@@ -9247,8 +9469,8 @@ async function handleMeta(command, cmdArgs, flags, format) {
           }
           console.log();
           console.log("Next steps:");
-          for (const step of result.nextSteps) {
-            console.log(`  → ${step}`);
+          for (const step2 of result.nextSteps) {
+            console.log(`  → ${step2}`);
           }
         } else {
           error("Initialization failed");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@datacore-one/cli",
-  "version": "1.0.2",
+  "version": "1.0.3",
   "description": "CLI for setting up and managing Datacore installations",
   "type": "module",
   "main": "dist/index.js",