stellavault 0.3.0 → 0.4.1

package/CHANGELOG.md

@@ -0,0 +1,84 @@
+# Changelog
+
+## [0.4.1] - 2026-04-07
+
+### Features
+- **Binary File Ingest** — PDF (unpdf), DOCX (mammoth), PPTX (officeparser), XLSX (SheetJS) text extraction
+- **Auto Pipeline** — `ingest` now auto-runs `compile` → wiki generated automatically
+- **Web File Upload** — Drag & drop files in browser (POST /api/ingest/file, 50MB limit)
+- **Mobile/PWA** — Responsive IngestPanel, service worker registration, installable as app
+- **Express: stellavault draft** — Generate blog/report/outline from vault knowledge
+- **MCP generate-draft** — 20th MCP tool: Claude writes drafts using vault context (free in Claude Code)
+- **CLI --ai flag** — `stellavault draft --ai` uses Claude API for full AI-generated drafts
+- **Configurable folders** — Override raw/_wiki/_literature/ in .stellavault.json
+- **Multilingual embeddings** — paraphrase-multilingual-MiniLM-L12-v2 (50+ languages)
+
+### Changes
+- Binary files default to fleeting stage (Zettelkasten principle: all inputs start as fleeting)
+- Repositioned as "Self-compiling knowledge MCP server"
+- .npmignore excludes PDF (was 16MB in npm package)
+- MCP tools: 19 → 20
+
+### Fixes
+- CLI YouTube ingest now properly calls extractYouTubeContent
+- officeparser type cast fix (OfficeParserAST → string)
+- unpdf text array handling (pages returned as array, not string)
+
+## [0.4.0] - 2026-04-06
+
+### Features
+- **i18n Global Service** — Full EN/KO/JA/ZH language switcher for web UI; saved notes follow user's language setting
+- **Web UI Ingest Panel** — Add knowledge from browser (+) button, no terminal needed
+- **YouTube Deep Extraction** — Full description, transcript with clickable timestamps, auto-summary, metadata (channel, views, duration)
+- **YouTube Transcript via yt-dlp** — Fallback to yt-dlp when YouTube bot protection blocks direct caption fetch
+- **Edit/Delete Notes from Web** — Edit and delete notes directly from web UI, syncs to Obsidian vault
+- **Ask Q&A Web UI** — Intelligence > Ask tab for querying your knowledge base from the browser
+- **Reindex from Web** — One-click reindex button, no terminal needed
+- **Recent Saves Navigation** — Click recent saves to navigate to node in 3D graph
+- **Auto-index after Ingest** — New notes are automatically indexed and graph refreshes
+- **Onboarding Guide** — 4-step walkthrough for new users
+- **LLM Knowledge Base** — `stellavault ask` (Q&A + auto-filing), `compile` (raw→wiki), `lint` (health check), `digest --visual` (Mermaid charts)
+- **Zettelkasten System** — Luhmann-style index codes, frontmatter scan, inbox zero, atomicity verification, orphan/broken link detection
+- **Unified Ingest Pipeline** — URL/file/text auto-classification, `stellavault ingest`, `promote`, `autopilot` flywheel
+- **Fleeting Capture** — `stellavault fleeting` for quick thoughts
+
+### Fixes
+- YouTube extractor v2 — HTML entities, tags cleanup, summary quality, duplicate frontmatter removal
+- YouTube full description extraction (shortDescription JSON parsing)
+- CLI YouTube ingest now properly calls extractYouTubeContent instead of basic HTML scrape
+- Strict node matching — exact title/path only, no partial match
+- React hooks order in Layout, ConstellationView, MultiverseView
+- Natural Korean translations (감쇠→잊고 있는 것, 갭→빠진 지식)
+- Reindex API — pass vaultPath, use all-MiniLM-L6-v2, error details
+
+### Security
+- Path traversal protection (archiveFile, ingest)
+- YAML injection prevention (sanitizeYaml)
+- SSRF protection (private IP blocking)
+- Empty catch blocks → proper error logging
+
+### Infrastructure
+- MCP: 19 tools | CLI: 36+ commands | Tests: 127 ALL PASS
+- Hardcoded Korean removed — core modules default to English
+- Subpath exports for youtube-extractor module
+
+## [0.3.0] - 2026-04-04
+
+### Features
+- 3D Knowledge Graph with Three.js / React Three Fiber
+- Hybrid search (vector + keyword + RRF)
+- Memory decay tracking (FSRS algorithm)
+- MCP server with 16 tools
+- Notion ↔ Obsidian sync (packages/sync)
+- Web UI with constellation/multiverse views
+
+## [0.2.0] - 2026-04-03
+
+- Initial Obsidian vault indexer
+- Vector store with all-MiniLM-L6-v2
+- Basic CLI commands
+
+## [0.1.0] - 2026-04-02
+
+- Project inception
+- Notion-Obsidian sync tool

package/README.md

@@ -1,149 +1,152 @@
 # Stellavault
 
-> **Notes die in folders. Stellavault keeps your knowledge alive.**
+> **Self-compiling knowledge MCP server** — ingest anything, auto-organize into Zettelkasten wiki, and let Claude access your entire knowledge base.
 
-Your Obsidian vault is more than files. It's a living network — connections emerge, memories fade, gaps appear. Stellavault turns it into a knowledge system that **discovers hidden connections**, **detects fading memories**, **finds blind spots**, and **gives AI agents direct access to everything you know**.
+Drop a PDF, paste a YouTube link, type a thought — Stellavault compiles it into structured knowledge, connects the dots, and gives your AI agent full access through 20 MCP tools.
 
-## 30-Second Setup
+<p align="center">
+  <img src="images/screenshots/graph-dark-full.png" alt="3D Knowledge Graph" width="800" />
+  <br><em>Your vault as a neural network. Clusters form constellations.</em>
+</p>
 
-```bash
-# Install globally
-npm install -g stellavault
+## Two Core Ideas
 
-# Interactive setup wizard
-stellavault init
-
-# Or manually: index your vault + launch 3D graph
-stellavault index /path/to/obsidian/vault
-stellavault graph
+**1. "Drop it and forget it"** (Karpathy's Self-Compiling Knowledge)
+```
+Any input → auto-classify → raw/ → compile → wiki → connected knowledge
 ```
+PDF, DOCX, YouTube, URL, text — everything goes through the same pipeline. You never manually organize.
 
-That's it. Open `http://localhost:5173` to see your knowledge come alive in 3D.
+**2. "Claude knows what you know"** (MCP Integration)
+```bash
+claude mcp add stellavault -- stellavault serve
+```
+20 MCP tools give Claude direct access to search, ask, draft, and navigate your entire knowledge base.
 
-## Give Your AI Agent Memory
+## 5-Minute Setup
 
 ```bash
-claude mcp add stellavault -- stellavault serve
+npm install -g stellavault
+stellavault init          # Interactive setup + vault indexing
+stellavault graph         # Launch 3D graph + API server
 ```
 
-Now Claude Code can search your notes, track your decisions, tell you what's fading, and give you a daily knowledge briefing — using 17+ MCP tools.
+> **Prerequisites**: Node.js 20+
 
-## What It Does
+## The Pipeline
 
-**Understands** — Vectorizes every note locally (no API keys needed). Hybrid search combines BM25 + cosine similarity + RRF fusion.
+```
+Capture ──→ Organize ──→ Distill ──→ Express
 
-**Remembers** — FSRS spaced repetition tracks what you're forgetting. `stellavault decay` shows what's fading. `stellavault review` runs a review session.
+stellavault ingest <anything>     # PDF, DOCX, URL, YouTube, text
+  → auto-extract text             # unpdf, mammoth, yt-dlp
+  → raw/ (fleeting)               # Zettelkasten inbox
+  → compile → _wiki/              # Auto: concepts + backlinks
+  → stellavault draft "topic"     # Blog, report, or outline
+```
 
-**Discovers** — Gap detector finds missing connections. Duplicate finder catches redundancy. Contradiction detector spots conflicting statements. Learning path tells you what to study next.
+### Ingest Anything
 
-**Visualizes** — Interactive 3D neural graph with constellation view, timeline slider, type filters, health dashboard, and keyboard navigation.
+| Input | How |
+|-------|-----|
+| PDF, DOCX, PPTX, XLSX | `stellavault ingest report.pdf` — auto text extraction |
+| YouTube | `stellavault ingest https://youtu.be/...` — transcript + timestamps |
+| URL | `stellavault ingest https://...` — HTML → clean text |
+| Text | `stellavault ingest "quick thought"` |
+| Web UI | Drag & drop files in browser (mobile too) |
 
-**Connects** — Federation protocol links your vault to other Stellavault nodes via P2P. Search across the network without sharing your raw text. Multiverse UI shows your universe alongside connected peers.
+### Express: Get Knowledge Out
 
-## Key Features
+```bash
+stellavault draft "AI"                    # Rule-based scaffold (free)
+stellavault draft "AI" --ai               # Claude API writes full draft ($0.03)
+stellavault draft "AI" --format report    # Formal report format
+stellavault draft --format outline        # All-knowledge outline
+```
 
-| Category | Features |
-|----------|----------|
-| **Search** | Hybrid BM25+Vector+RRF, semantic search, search history |
-| **Intelligence** | FSRS decay, gap detection, duplicates, contradictions, predictive gaps, learning paths |
-| **Visualization** | 3D graph, constellation view, timeline, type filter, health dashboard, embed widget |
-| **AI Integration** | 17+ MCP tools, custom MCP tool builder (YAML), agentic graph construction |
-| **Federation** | P2P search, multiverse UI, reputation system, trust scoring, differential privacy |
-| **Security** | E2E cloud sync (AES-256-GCM), team auth (RBAC), sharing controls, SSRF/XSS protection |
-| **Platform** | Web dashboard, PWA, voice capture (Whisper), Notion sync, multi-vault, i18n (en/ko/ja/zh) |
-| **Extensibility** | Plugin SDK, webhook system, Knowledge Pack marketplace |
+Or in Claude Code: *"Write a blog post about machine learning from my notes"* — Claude uses MCP `generate-draft` tool (free, no API key).
 
-## CLI (28+ commands)
+## Daily Commands
 
 ```bash
-# Core
-stellavault init                  # Interactive setup wizard
-stellavault index <vault-path>    # Vectorize your vault
-stellavault search <query>        # Semantic search
-stellavault graph                 # Launch 3D graph
-stellavault serve                 # MCP server for AI agents
-stellavault status                # Index stats
-
-# Intelligence
-stellavault decay                 # What's fading?
-stellavault learn                 # AI learning path
-stellavault brief                 # Daily knowledge briefing
-stellavault digest                # Weekly report
-stellavault review                # FSRS review session
-stellavault gaps                  # Knowledge gap detection
-stellavault duplicates            # Duplicate detection
-stellavault contradictions        # Contradiction detection
-
-# Federation
-stellavault federate join         # Join P2P network
-stellavault federate status       # Node identity
-
-# Multi-Vault
-stellavault vault add <id> <path> # Register a vault
-stellavault vault search-all <q>  # Search across all vaults
-
-# Cloud
-stellavault cloud sync            # E2E encrypted backup
-stellavault cloud restore         # Restore from cloud
-
-# More
-stellavault clip <url>            # Web/YouTube clipper
-stellavault sync                  # Notion → Obsidian
-stellavault capture <audio>       # Voice → knowledge (Whisper)
-stellavault card                  # SVG profile card
-stellavault pack <cmd>            # Knowledge Pack management
+stellavault ask "What did I learn about X?"   # Q&A from vault
+stellavault brief                              # Morning knowledge briefing
+stellavault decay                              # What's fading from memory?
+stellavault lint                               # Health score (0-100)
+stellavault learn                              # AI learning path
+stellavault digest --visual                    # Weekly Mermaid chart report
 ```
 
-Use short alias `sv` for all commands: `sv graph`, `sv decay`, `sv learn`
-
-## MCP Tools (17+)
+## MCP Tools (20)
 
 | Tool | What it does |
 |------|-------------|
 | `search` | Hybrid search (BM25 + vector + RRF) |
+| `ask` | Q&A with optional vault filing |
+| `generate-draft` | Gather vault context for AI draft writing |
 | `get-document` | Full document with metadata |
 | `get-related` | Semantically similar documents |
 | `list-topics` | Topic cloud |
 | `get-decay-status` | Memory decay report |
 | `get-morning-brief` | Daily knowledge briefing |
 | `get-learning-path` | AI learning recommendations |
-| `federated-search` | Search across P2P network |
-| `create-knowledge-node` | AI creates notes during conversation |
-| `create-knowledge-link` | AI creates links between notes |
-| `log-decision` / `find-decisions` | Technical decision journal |
+| `detect-gaps` | Knowledge gap analysis |
+| `get-evolution` | Semantic drift tracking |
+| `link-code` | Code-knowledge connections |
+| `create-knowledge-node` | AI creates wiki-quality notes |
+| `create-knowledge-link` | AI connects existing notes |
+| `log-decision` / `find-decisions` | Decision journal |
 | `create-snapshot` / `load-snapshot` | Context snapshots |
 | `generate-claude-md` | Auto-generate CLAUDE.md |
 | `export` | JSON/CSV export |
 
-## Federation — P2P Knowledge Network
-
-Each Stellavault is a node. Connect to discover knowledge across the network — without sharing your raw text.
+## Zettelkasten (Luhmann + Karpathy)
 
 ```bash
-stellavault federate join --name "my-node"
-# Interactive mode:
-federation> search kubernetes deployment
-#  87% "K8s Rolling Update Guide" [peer-alice]
-#     Kubernetes에서 무중단 배포를 위해...
-federation> peers
-#  alice (1,209 docs) [trust: 88]
-#  bob (47 docs) [trust: 72]
+stellavault fleeting "raw idea"                # → raw/
+stellavault ingest report.pdf                  # → auto text extract → raw/
+stellavault compile                            # → raw/ → _wiki/ (concepts + backlinks)
+stellavault promote note.md --to permanent     # Upgrade stage
+stellavault autopilot                          # Full cycle: inbox → compile → lint → archive
 ```
 
-**Privacy**: Only titles + similarity scores + 50-char masked snippets cross the network. Never raw text. Differential privacy noise on embeddings. Sharing controls per tag/folder.
+- **3-stage flow**: fleeting → literature → permanent
+- **Luhmann index codes**: auto-assigned (1A → 1A1)
+- **Frontmatter-first scanning**: 10x token reduction
+- **Configurable folders**: override raw/_wiki/_literature/ in `.stellavault.json`
 
-**Trust**: Web of Trust + automatic reputation scoring (consistency, consensus, helpfulness).
+```json
+{
+  "vaultPath": "/path/to/vault",
+  "folders": {
+    "fleeting": "01-Inbox",
+    "literature": "02-Reading",
+    "permanent": "03-Notes",
+    "wiki": "04-Wiki"
+  }
+}
+```
 
-## Architecture
+## Intelligence
 
-```
-stellavault/
-├── packages/
-│   ├── core/       Search, MCP, API, Intelligence, Federation, Cloud, Team, i18n
-│   ├── cli/        28+ commands
-│   ├── graph/      3D visualization + Multiverse UI (React Three Fiber)
-│   └── sync/       Notion ↔ Obsidian sync
-```
+| Feature | Command |
+|---------|---------|
+| FSRS Decay | `sv decay` — spaced repetition memory tracking |
+| Gap Detection | `sv gaps` — missing connections between topics |
+| Contradictions | `sv contradictions` — conflicting statements |
+| Duplicates | `sv duplicates` — redundant notes |
+| Learning Path | `sv learn` — AI review recommendations |
+| Code Linker | MCP `link-code` — connect code to knowledge |
+
+## 3D Visualization
+
+- Neural graph with cluster coloring
+- Constellation view (MST star patterns)
+- Heatmap overlay (activity score)
+- Timeline slider (creation/modification filter)
+- Decay overlay (fading knowledge)
+- Dark/Light theme
+- Mobile responsive + PWA installable
 
 ## Tech Stack
 
@@ -151,25 +154,12 @@ stellavault/
 |-------|------|
 | Runtime | Node.js 20+ (ESM, TypeScript) |
 | Vector Store | SQLite-vec (local, no server) |
-| Embedding | all-MiniLM-L6-v2 (local, no API key) |
+| Embedding | paraphrase-multilingual-MiniLM-L12-v2 (local, 50+ languages) |
 | Search | BM25 + Cosine + RRF Fusion |
-| 3D | React Three Fiber + Three.js + Zustand |
+| File Parsing | unpdf, mammoth, officeparser, SheetJS |
 | Memory | FSRS (Free Spaced Repetition Scheduler) |
-| P2P | Hyperswarm (NAT traversal + DHT) |
-| AI | MCP (Model Context Protocol) |
-| Security | AES-256-GCM, HMAC-SHA256, Differential Privacy |
-
-## Configuration
-
-```json
-{
-  "vaultPath": "/path/to/obsidian/vault",
-  "dbPath": "~/.stellavault/index.db",
-  "embedding": { "model": "local", "localModel": "all-MiniLM-L6-v2" },
-  "search": { "defaultLimit": 10, "rrfK": 60 },
-  "mcp": { "mode": "stdio", "port": 3333 }
-}
-```
+| 3D | React Three Fiber + Three.js |
+| AI | MCP (Model Context Protocol) + Anthropic SDK |
 
 ## License
 
@@ -177,6 +167,6 @@ MIT
 
 ## Links
 
-- [Wiki: Vault Structure Guide](docs/wiki/vault-structure.md)
-- [Wiki: Notion Setup](docs/wiki/notion-setup.md)
-- [Wiki: Federation Guide](docs/wiki/federation-guide.md)
+- [Obsidian Plugin](https://github.com/Evanciel/stellavault-obsidian)
+- [npm](https://www.npmjs.com/package/stellavault)
+- [GitHub Releases](https://github.com/Evanciel/stellavault/releases)

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "stellavault",
-  "version": "0.3.0",
-  "description": "Turn your Obsidian vault into a 3D neural knowledge graph with AI-powered search, memory decay tracking, and MCP integration.",
+  "version": "0.4.1",
+  "description": "Self-compiling knowledge MCP server — ingest anything, auto-organize into Zettelkasten wiki, search with AI, and let Claude access your entire knowledge base.",
   "repository": {
     "type": "git",
     "url": "https://github.com/Evanciel/stellavault"

package/packages/cli/dist/commands/ask-cmd.d.ts

@@ -0,0 +1,4 @@
+export declare function askCommand(question: string, options: {
+    save?: boolean;
+}): Promise<void>;
+//# sourceMappingURL=ask-cmd.d.ts.map

package/packages/cli/dist/commands/ask-cmd.js

@@ -0,0 +1,35 @@
+// stellavault ask — Q&A + auto-filing CLI command
+import chalk from 'chalk';
+import { loadConfig, createKnowledgeHub, askVault } from '@stellavault/core';
+export async function askCommand(question, options) {
+    if (!question || question.trim().length < 2) {
+        console.error(chalk.yellow('Usage: stellavault ask "your question here" [--save]'));
+        console.error(chalk.dim('\nSearch Mode: finds relevant notes from your vault.'));
+        console.error(chalk.dim('For AI-powered answers, use MCP: claude mcp add stellavault -- stellavault serve'));
+        process.exit(1);
+    }
+    const config = loadConfig();
+    const hub = createKnowledgeHub(config);
+    console.error(chalk.dim('Searching your knowledge (local search mode)...'));
+    await hub.store.initialize();
+    await hub.embedder.initialize();
+    const result = await askVault(hub.searchEngine, question, {
+        limit: 10,
+        save: options.save ?? false,
+        vaultPath: config.vaultPath,
+    });
+    // 출력
+    console.log('');
+    console.log(result.answer);
+    if (result.savedTo) {
+        console.log('');
+        console.log(chalk.green(`Saved to: ${result.savedTo}`));
+    }
+    if (result.sources.length > 0 && !options.save) {
+        console.log('');
+        console.log(chalk.dim('Tip: Add --save to file this answer into your vault.'));
+        console.log(chalk.dim('For AI-generated answers: use Claude Code with MCP integration.'));
+    }
+    await hub.store.close?.();
+}
+//# sourceMappingURL=ask-cmd.js.map

package/packages/cli/dist/commands/autopilot-cmd.d.ts

@@ -0,0 +1,4 @@
+export declare function autopilotCommand(options: {
+    once?: boolean;
+}): Promise<void>;
+//# sourceMappingURL=autopilot-cmd.d.ts.map

package/packages/cli/dist/commands/autopilot-cmd.js

@@ -0,0 +1,76 @@
+// stellavault autopilot — 자율형 지식 플라이휠
+// ingest(inbox) → compile → lint → index → 반복
+import chalk from 'chalk';
+import { loadConfig, createKnowledgeHub, compileWiki, lintKnowledge, getInboxItems, archiveFile } from '@stellavault/core';
+import { resolve } from 'node:path';
+export async function autopilotCommand(options) {
+    const config = loadConfig();
+    const vaultPath = config.vaultPath;
+    console.log(chalk.bold('\n  ✦ Stellavault Autopilot'));
+    console.log(chalk.dim('  Knowledge flywheel: inbox → compile → lint → repeat\n'));
+    // Step 1: Inbox 확인
+    console.log(chalk.cyan('Step 1/4: Checking inbox...'));
+    const inbox = getInboxItems(vaultPath);
+    if (inbox.length === 0) {
+        console.log(chalk.dim('  No new items in raw/ folder.'));
+    }
+    else {
+        console.log(chalk.green(`  ${inbox.length} new items found.`));
+        for (const item of inbox.slice(0, 5)) {
+            console.log(chalk.dim(`    - ${item.title} (${item.wordCount} words)`));
+        }
+        if (inbox.length > 5)
+            console.log(chalk.dim(`    ... and ${inbox.length - 5} more`));
+    }
+    // Step 2: Compile
+    console.log(chalk.cyan('\nStep 2/4: Compiling wiki...'));
+    const rawPath = resolve(vaultPath, 'raw');
+    const wikiPath = resolve(vaultPath, '_wiki');
+    const compileResult = compileWiki(rawPath, wikiPath);
+    if (compileResult.rawDocCount > 0) {
+        console.log(chalk.green(`  Compiled ${compileResult.rawDocCount} raw → ${compileResult.wikiArticles.length} wiki articles`));
+        console.log(chalk.dim(`  Concepts: ${compileResult.concepts.length}`));
+        // Archive processed raw files
+        for (const item of inbox) {
+            try {
+                archiveFile(resolve(vaultPath, 'raw', item.filePath));
+            }
+            catch { /* skip */ }
+        }
+        console.log(chalk.dim(`  Archived ${inbox.length} processed items.`));
+    }
+    else {
+        console.log(chalk.dim('  No raw documents to compile.'));
+    }
+    // Step 3: Lint
+    console.log(chalk.cyan('\nStep 3/4: Running health check...'));
+    const hub = createKnowledgeHub(config);
+    await hub.store.initialize();
+    const lintResult = await lintKnowledge(hub.store);
+    const scoreColor = lintResult.score >= 80 ? chalk.green : lintResult.score >= 50 ? chalk.yellow : chalk.red;
+    console.log(`  Health: ${scoreColor(lintResult.score + '/100')}`);
+    const critical = lintResult.issues.filter(i => i.severity === 'critical').length;
+    const warnings = lintResult.issues.filter(i => i.severity === 'warning').length;
+    if (critical > 0)
+        console.log(chalk.red(`  Critical: ${critical}`));
+    if (warnings > 0)
+        console.log(chalk.yellow(`  Warnings: ${warnings}`));
+    // Step 4: Summary
+    console.log(chalk.cyan('\nStep 4/4: Summary'));
+    console.log(chalk.dim('─'.repeat(40)));
+    console.log(`  Inbox processed: ${inbox.length}`);
+    console.log(`  Wiki articles: ${compileResult.wikiArticles.length}`);
+    console.log(`  Health score: ${lintResult.score}/100`);
+    console.log(`  Issues: ${lintResult.issues.length}`);
+    if (lintResult.suggestions.length > 0) {
+        console.log(chalk.cyan('\n  Suggestions:'));
+        for (const s of lintResult.suggestions.slice(0, 3)) {
+            console.log(chalk.dim(`    → ${s}`));
+        }
+    }
+    console.log(chalk.dim('\n─'.repeat(40)));
+    console.log(chalk.dim('\n  Next: run `stellavault index` to update search vectors.'));
+    console.log(chalk.green('  Autopilot complete.\n'));
+    await hub.store.close?.();
+}
+//# sourceMappingURL=autopilot-cmd.js.map

package/packages/cli/dist/commands/compile-cmd.d.ts

@@ -0,0 +1,6 @@
+export declare function compileCommand(options: {
+    raw?: string;
+    wiki?: string;
+    force?: boolean;
+}): Promise<void>;
+//# sourceMappingURL=compile-cmd.d.ts.map

package/packages/cli/dist/commands/compile-cmd.js

@@ -0,0 +1,30 @@
+// stellavault compile — raw → wiki 컴파일 CLI
+import chalk from 'chalk';
+import { loadConfig, compileWiki } from '@stellavault/core';
+import { resolve } from 'node:path';
+export async function compileCommand(options) {
+    const config = loadConfig();
+    const vaultPath = config.vaultPath;
+    const rawPath = resolve(vaultPath, options.raw ?? 'raw');
+    const wikiPath = resolve(vaultPath, options.wiki ?? '_wiki');
+    console.error(chalk.dim(`Raw: ${rawPath}`));
+    console.error(chalk.dim(`Wiki: ${wikiPath}`));
+    console.error('');
+    const result = compileWiki(rawPath, wikiPath, { force: options.force });
+    if (result.rawDocCount === 0) {
+        console.error(chalk.yellow(`No documents found in ${rawPath}`));
+        console.error(chalk.dim('Create a raw/ folder in your vault and add .md/.txt files.'));
+        return;
+    }
+    console.log(chalk.green(`Compiled ${result.rawDocCount} raw docs → ${result.wikiArticles.length} wiki articles`));
+    console.log(chalk.dim(`Concepts: ${result.concepts.length}`));
+    console.log(chalk.dim(`Index: ${result.indexFile}`));
+    if (result.concepts.length > 0) {
+        console.log('');
+        console.log(chalk.cyan('Top concepts:'));
+        for (const c of result.concepts.slice(0, 10)) {
+            console.log(`  ${c}`);
+        }
+    }
+}
+//# sourceMappingURL=compile-cmd.js.map

package/packages/cli/dist/commands/digest-cmd.d.ts

@@ -1,4 +1,5 @@
 export declare function digestCommand(options: {
     days?: string;
+    visual?: boolean;
 }): Promise<void>;
 //# sourceMappingURL=digest-cmd.d.ts.map

package/packages/cli/dist/commands/digest-cmd.js

@@ -75,5 +75,62 @@ export async function digestCommand(options) {
     const report = await decayEngine.computeAll();
     console.log(`\n🧠 건강도: R=${report.averageR} | 감쇠 ${report.decayingCount}개 | 위험 ${report.criticalCount}개`);
     console.log(chalk.dim('\n═'.repeat(50)));
+    // --visual: Mermaid 다이어그램 + 요약을 .md로 저장
+    if (options.visual) {
+        const { writeFileSync, mkdirSync, existsSync } = await import('node:fs');
+        const { join, resolve } = await import('node:path');
+        const outputDir = resolve(config.vaultPath, '_stellavault/digests');
+        if (!existsSync(outputDir))
+            mkdirSync(outputDir, { recursive: true });
+        const date = new Date().toISOString().split('T')[0];
+        const filename = `digest-${date}.md`;
+        const outputPath = join(outputDir, filename);
+        // Mermaid 파이 차트
+        const pieData = (typeStats.length > 0 ? typeStats : [{ type: 'note', cnt: 1 }])
+            .map((t) => `    "${t.type}" : ${t.cnt}`)
+            .join('\n');
+        // Mermaid 타임라인
+        const timelineData = dailyActivity
+            .map((d) => `    ${d.day.slice(5)} : ${d.cnt}`)
+            .join('\n');
+        const md = [
+            '---',
+            `title: "Weekly Digest — ${date}"`,
+            'type: digest',
+            `date: ${new Date().toISOString()}`,
+            'source: stellavault-digest',
+            '---',
+            '',
+            `# Weekly Knowledge Digest — ${date}`,
+            '',
+            `## Summary`,
+            `- Total access: **${totalAccess}** in ${days} days`,
+            `- Average R: **${report.averageR.toFixed(2)}**`,
+            `- Decaying: ${report.decayingCount} | Critical: ${report.criticalCount}`,
+            '',
+            '## Activity by Type',
+            '```mermaid',
+            'pie title Note Types Accessed',
+            pieData,
+            '```',
+            '',
+            '## Daily Activity',
+            '```mermaid',
+            'xychart-beta',
+            `    title "Daily Activity (${days} days)"`,
+            '    x-axis [' + dailyActivity.map((d) => `"${d.day.slice(5)}"`).join(', ') + ']',
+            '    y-axis "Access Count"',
+            '    bar [' + dailyActivity.map((d) => d.cnt).join(', ') + ']',
+            '```',
+            '',
+            topDocs.length > 0 ? '## Most Accessed Notes\n' + topDocs.map((d) => `1. **${d.title}** — ${d.cnt} times`).join('\n') : '',
+            '',
+            '---',
+            `*Generated by \`stellavault digest --visual\` on ${new Date().toISOString()}*`,
+        ].filter(Boolean).join('\n');
+        writeFileSync(outputPath, md, 'utf-8');
+        console.log(chalk.green(`\nVisual digest saved: ${filename}`));
+        console.log(chalk.dim(`Open in Obsidian to see Mermaid charts.`));
+    }
 }
 //# sourceMappingURL=digest-cmd.js.map

package/packages/cli/dist/commands/draft-cmd.d.ts

@@ -0,0 +1,5 @@
+export declare function draftCommand(topic: string | undefined, options: {
+    format?: string;
+    ai?: boolean;
+}): Promise<void>;
+//# sourceMappingURL=draft-cmd.d.ts.map