@beomjk/emdd 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 EMDD Contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,153 @@
+# EMDD: Evolving Mindmap-Driven Development
+
+> **A methodology that gives structure to R&D exploration through an AI-maintained evolving knowledge graph -- without killing the exploration itself.**
+
+## Demo
+
+<img src="docs/assets/demo.svg" alt="EMDD Demo" width="720">
+
+## What is EMDD?
+
+Too much structure suffocates research. Too little structure evaporates it. Existing approaches each solve one piece -- Zettelkasten gives bottom-up emergence, HDD gives hypothesis testing, DDP gives risk prioritization -- but none of them track the *relationships* between what you know, what you don't know, and what to explore next. EMDD fills that gap: it is a lightweight, AI-maintained knowledge graph that structures your exploration as it happens, surfaces blind spots, and remembers every dead end so you never walk it twice.
+
+## Who is it for?
+
+- **Solo researchers or small teams doing exploratory R&D** where the destination is unknown -- visual inspection R&D, architecture spikes, open-ended investigations.
+- **Developers working with AI coding assistants** (e.g., Claude Code) who want the AI to maintain the knowledge structure while they retain judgment.
+- **Anyone who has lost track of what they tried last week**, why they abandoned an approach, or which assumptions remain untested.
+- **Teams that need more rigor than a scratchpad** but less overhead than a project management system.
+- **Researchers who want to know what to explore next**, not just what they have already done.
+
+## The EMDD Equation
+
+```
+EMDD = Zettelkasten's bottom-up emergence
+     + DDP's risk-first validation
+     + InfraNodus's structural gap detection
+     + Graphiti's temporal evolution
+     ─────────────────────────────────
+       Autonomous maintenance and suggestions by an AI agent
+```
+
+Delegate cognitive load to the graph and the AI, but never delegate judgment.
+
+## How It Works
+
+EMDD has three roles. The **Researcher** exercises taste and judgment -- deciding which directions are worth pursuing, creating hypotheses, and making intuitive leaps the graph cannot derive on its own. The **Graph** is the living knowledge structure: a map of what is known, what remains unknown, and what has been tried. The **Agent** (AI) is the graph's gardener -- maintaining connections, detecting patterns and gaps, and suggesting what to explore next. Suggestions are always suggestions, never decisions.
+
+### The Knowledge Graph
+
+| Node Type | Purpose |
+|-----------|---------|
+| **Knowledge** | Confirmed facts, literature, domain rules |
+| **Hypothesis** | Testable claims with confidence scores and kill criteria |
+| **Experiment** | Units of work that validate or refute hypotheses |
+| **Finding** | Facts or patterns discovered from experiments (observations, insights, negatives) |
+| **Question** | Open research questions that need answers |
+| **Decision** | Recorded decisions with rationale and alternatives considered |
+| **Episode** | Record of one exploration session -- what was tried, what is next |
+
+### The Lifecycle
+
+```
+Question ──> Hypothesis ──> Experiment ──> Finding
+                                             │
+                              ┌───────────────┤
+                              v               v
+                          Knowledge      New Question
+                        (promoted)      (the cycle continues)
+```
+
+Hypotheses move through `PROPOSED -> TESTING -> SUPPORTED / REFUTED / REVISED`. Findings accumulate evidence. When a Finding has sufficient independent support, it is promoted to Knowledge. Refuted hypotheses are preserved -- the knowledge of *why* something failed is itself knowledge.
+
+## Installation
+
+```bash
+npm install -g emdd
+```
+
+Or use directly with npx:
+
+```bash
+npx emdd <command>
+```
+
+## Quick Start
+
+```bash
+# Initialize an EMDD project
+emdd init my-research
+
+# Create your first nodes
+cd my-research
+emdd new question "what-causes-defects" --lang en
+emdd new hypothesis "surface-cracks-from-stress"
+
+# Link them
+emdd link hyp-001 qst-001 spawned_from
+
+# Check graph health
+emdd lint
+emdd health
+```
+
+See the [Quick Start Guide](docs/QUICK_START.md) for a full walkthrough.
+
+## CLI Commands
+
+| Command | Description |
+|---------|-------------|
+| `emdd init [path]` | Initialize a new EMDD project |
+| `emdd new <type> <slug>` | Create a node (hypothesis, experiment, finding, ...) |
+| `emdd link <source> <target> <relation>` | Add a link between nodes |
+| `emdd update <node-id> --set key=value` | Update node frontmatter |
+| `emdd done <episode-id> "<item>"` | Mark an episode item as done |
+| `emdd lint [path]` | Validate schema and link integrity |
+| `emdd health [path]` | Show graph health dashboard |
+| `emdd check [path]` | Check consolidation triggers |
+| `emdd promote [path]` | Identify promotion candidates |
+| `emdd backlog [path]` | List incomplete items across all nodes |
+| `emdd index [path]` | Generate `_index.md` |
+| `emdd graph [path]` | Generate `_graph.mmd` (Mermaid) |
+
+All commands support `--lang en|ko` for bilingual output.
+
+## Phased Adoption
+
+You do not need to adopt everything at once. Start lite and add structure as you need it.
+
+| Phase | Duration | Node Types | Daily Overhead | You're doing it right when... |
+|-------|----------|------------|----------------|-------------------------------|
+| **Lite** | Week 1-2 | 4 (Hypothesis, Experiment, Finding, Episode) | ~15 min | You can open last week's Episode and immediately know what to do next |
+| **Standard** | Week 3-4 | 6 (+Knowledge, Question) | ~25 min | Findings regularly get promoted to Knowledge |
+| **Full** | Week 5+ | 7 (+Decision, all edge types, all ceremonies) | ~45 min | The graph tells you what to explore next |
+
+See [section 11 of the specification](docs/spec/SPEC_EN.md#11-phased-adoption-guide) for details on each phase.
+
+## Documentation
+
+- [EMDD in 5 Minutes](docs/TUTORIAL.md) -- copy-paste tutorial
+- [Quick Start Guide](docs/QUICK_START.md) -- get started in 15 minutes
+- [Example Graph](examples/ml-backbone-selection/) -- a complete 13-node research narrative
+- [Full Specification](docs/spec/SPEC_EN.md) -- the complete methodology
+- [Philosophy](docs/PHILOSOPHY.md) -- why EMDD exists
+- [Operations](docs/OPERATIONS.md) -- research loops, ceremonies, adoption
+- [Tool Comparison](docs/COMPARISON.md) -- EMDD vs. Obsidian, Zettelkasten, DDP, HDD, nbdev, and more
+- [Glossary](docs/GLOSSARY.md) -- definitions of all EMDD terms
+- [한국어 스펙](docs/spec/SPEC_KO.md) -- Korean specification
+
+## What EMDD is NOT
+
+- **Not a project management tool.** No deadlines, no progress percentages -- it tracks what you know and what you don't.
+- **Not a knowledge base.** The value is in the tensions, contradictions, and gaps between information, not in tidy organization.
+- **Not SDD with a graph bolted on.** Direction emerges from exploration; the specification does not come first.
+- **Not a personal knowledge management system.** It is project-scoped working memory, not a second brain for a lifetime.
+- **Not outsourcing research to AI.** The AI prunes branches and points to empty ground. The researcher decides where to walk.
+
+## Contributing
+
+Contributions are welcome -- whether that is trying EMDD on your own project and reporting what worked, proposing changes to the spec, or building tooling. See [CONTRIBUTING.md](docs/CONTRIBUTING.md) for guidelines and the RFC process.
+
+## License
+
+[MIT](LICENSE)

package/dist/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/cli.js

@@ -0,0 +1,158 @@
+#!/usr/bin/env node
+import { Command } from 'commander';
+import { initCommand } from './commands/init.js';
+import { newCommand } from './commands/new.js';
+import { lintCommand } from './commands/lint.js';
+import { healthCommand } from './commands/health.js';
+import { checkCommand } from './commands/check.js';
+import { promoteCommand } from './commands/promote.js';
+import { updateCommand } from './commands/update.js';
+import { linkCommand } from './commands/link.js';
+import { doneCommand } from './commands/done.js';
+import { indexCommand } from './commands/index.js';
+import { graphCommand } from './commands/graph.js';
+import { backlogCommand } from './commands/backlog.js';
+import { resolveGraphDir } from './graph/loader.js';
+import { startMcpServer } from './mcp-server/index.js';
+const program = new Command();
+program
+    .name('emdd')
+    .description('CLI for Evolving Mindmap-Driven Development')
+    .version('0.1.0');
+program
+    .command('init [path]')
+    .description('Initialize EMDD project')
+    .option('--lang <locale>', 'Language', 'en')
+    .option('--tool <tool>', 'AI tool rules to generate (claude|cursor|windsurf|cline|copilot|all)', 'claude')
+    .action((path, options) => {
+    initCommand(path, options);
+});
+program
+    .command('new <type> <slug>')
+    .description('Create a new node')
+    .option('--path <path>', 'Project path')
+    .action(async (type, slug, options) => {
+    await newCommand(type, slug, options);
+});
+program
+    .command('lint [path]')
+    .description('Validate graph schema and links')
+    .action(async (path) => {
+    await lintCommand(path);
+});
+program
+    .command('health [path]')
+    .description('Show health dashboard')
+    .action(async (path) => {
+    await healthCommand(path);
+});
+program
+    .command('check [path]')
+    .description('Check consolidation triggers')
+    .action(async (path) => {
+    const graphDir = resolveGraphDir(path);
+    const result = await checkCommand(graphDir);
+    if (result.triggers.length === 0) {
+        console.log('No consolidation triggers active.');
+    }
+    else {
+        for (const trigger of result.triggers) {
+            console.log(`TRIGGER  ${trigger.type}  ${trigger.message}`);
+        }
+    }
+});
+program
+    .command('promote [path]')
+    .description('Identify findings eligible for promotion')
+    .action(async (path) => {
+    const graphDir = resolveGraphDir(path);
+    const result = await promoteCommand(graphDir);
+    if (result.candidates.length === 0) {
+        console.log('No promotion candidates found.');
+    }
+    else {
+        for (const c of result.candidates) {
+            console.log(`CANDIDATE  ${c.id}  confidence=${c.confidence}  supports=${c.supports}`);
+        }
+    }
+});
+program
+    .command('update <node-id>')
+    .description('Update frontmatter fields on a node')
+    .option('--set <key=value...>', 'Key-value pairs to set')
+    .option('--path <path>', 'Project path')
+    .action(async (nodeId, options) => {
+    const graphDir = resolveGraphDir(options.path);
+    const updates = {};
+    if (options.set) {
+        const pairs = Array.isArray(options.set) ? options.set : [options.set];
+        for (const pair of pairs) {
+            const eqIdx = pair.indexOf('=');
+            if (eqIdx === -1) {
+                console.error(`Invalid key=value: ${pair}`);
+                process.exit(1);
+            }
+            updates[pair.slice(0, eqIdx)] = pair.slice(eqIdx + 1);
+        }
+    }
+    await updateCommand(graphDir, nodeId, updates);
+    console.log(`Updated ${nodeId}`);
+});
+program
+    .command('link <source> <target> <relation>')
+    .description('Add a link between nodes')
+    .option('--path <path>', 'Project path')
+    .action(async (source, target, relation, options) => {
+    const graphDir = resolveGraphDir(options.path);
+    await linkCommand(graphDir, source, target, relation);
+    console.log(`Linked ${source} -> ${target} (${relation})`);
+});
+program
+    .command('done <episode-id> <item>')
+    .description('Mark a checklist item as done')
+    .option('--path <path>', 'Project path')
+    .action(async (episodeId, item, options) => {
+    const graphDir = resolveGraphDir(options.path);
+    await doneCommand(graphDir, episodeId, item);
+    console.log(`Done: ${item}`);
+});
+program
+    .command('index [path]')
+    .description('Generate _index.md for the graph')
+    .action(async (path) => {
+    const graphDir = resolveGraphDir(path);
+    const result = await indexCommand(graphDir);
+    console.log(`Index generated: ${result.nodeCount} nodes`);
+});
+program
+    .command('graph [path]')
+    .description('Generate _graph.mmd Mermaid diagram')
+    .action(async (path) => {
+    const graphDir = resolveGraphDir(path);
+    const result = await graphCommand(graphDir);
+    console.log(`Graph generated: ${result.nodeCount} nodes, ${result.edgeCount} edges`);
+});
+program
+    .command('backlog')
+    .description('Show unchecked backlog items')
+    .option('--path <path>', 'Project path')
+    .option('--status <status>', 'Filter by status')
+    .action(async (options) => {
+    const graphDir = resolveGraphDir(options.path);
+    const result = await backlogCommand(graphDir, options.status);
+    if (result.items.length === 0) {
+        console.log('No backlog items.');
+    }
+    else {
+        for (const item of result.items) {
+            console.log(`[ ] ${item.episodeId}  ${item.text}`);
+        }
+    }
+});
+program
+    .command('mcp')
+    .description('Start MCP server over stdio')
+    .action(async () => {
+    await startMcpServer();
+});
+program.parse();

package/dist/commands/backlog.d.ts

@@ -0,0 +1,8 @@
+export interface BacklogItem {
+    text: string;
+    episodeId: string;
+}
+export interface BacklogResult {
+    items: BacklogItem[];
+}
+export declare function backlogCommand(graphDir: string, _statusFilter?: string): Promise<BacklogResult>;

package/dist/commands/backlog.js

@@ -0,0 +1,35 @@
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { glob } from 'glob';
+import matter from 'gray-matter';
+export async function backlogCommand(graphDir, _statusFilter) {
+    const episodeDir = join(graphDir, 'episodes');
+    const pattern = join(episodeDir, '*.md');
+    const files = await glob(pattern, { nodir: true });
+    const items = [];
+    for (const file of files.sort()) {
+        let content;
+        try {
+            content = readFileSync(file, 'utf-8');
+        }
+        catch {
+            continue;
+        }
+        let parsed;
+        try {
+            parsed = matter(content);
+        }
+        catch {
+            continue;
+        }
+        const episodeId = parsed.data?.id ?? '';
+        const body = parsed.content;
+        for (const line of body.split('\n')) {
+            const unchecked = line.match(/^- \[ \]\s+(.+)/);
+            if (unchecked) {
+                items.push({ text: unchecked[1].trim(), episodeId });
+            }
+        }
+    }
+    return { items };
+}

package/dist/commands/check.d.ts

@@ -0,0 +1,6 @@
+import type { CheckResult } from '../graph/types.js';
+/**
+ * Check consolidation triggers in the graph.
+ * Delegates to the pure operations.checkConsolidation function.
+ */
+export declare function checkCommand(graphDir: string): Promise<CheckResult>;

package/dist/commands/check.js

@@ -0,0 +1,8 @@
+import { checkConsolidation } from '../graph/operations.js';
+/**
+ * Check consolidation triggers in the graph.
+ * Delegates to the pure operations.checkConsolidation function.
+ */
+export async function checkCommand(graphDir) {
+    return checkConsolidation(graphDir);
+}

package/dist/commands/done.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Mark a checklist item as done in an episode node.
+ *
+ * Finds `- [ ] {item}` in the body and replaces with `- [x] {item}`.
+ * Throws if the item is not found.
+ */
+export declare function doneCommand(graphDir: string, episodeId: string, item: string): Promise<void>;

package/dist/commands/done.js

@@ -0,0 +1,34 @@
+import fs from 'node:fs';
+import { loadGraph } from '../graph/loader.js';
+/**
+ * Mark a checklist item as done in an episode node.
+ *
+ * Finds `- [ ] {item}` in the body and replaces with `- [x] {item}`.
+ * Throws if the item is not found.
+ */
+export async function doneCommand(graphDir, episodeId, item) {
+    const graph = await loadGraph(graphDir);
+    const node = graph.nodes.get(episodeId);
+    if (!node) {
+        throw new Error(`Node not found: ${episodeId}`);
+    }
+    const filePath = node.path;
+    const raw = fs.readFileSync(filePath, 'utf-8');
+    // Find lines matching the unchecked item
+    const lines = raw.split('\n');
+    const matches = [];
+    for (let i = 0; i < lines.length; i++) {
+        if (lines[i].includes('- [ ]') && lines[i].includes(item)) {
+            matches.push(i);
+        }
+    }
+    if (matches.length === 0) {
+        throw new Error(`Item not found in ${episodeId}: ${item}`);
+    }
+    if (matches.length > 1) {
+        throw new Error(`Multiple matches for '${item}' in ${episodeId}`);
+    }
+    // Replace the matched line
+    lines[matches[0]] = lines[matches[0]].replace('- [ ]', '- [x]');
+    fs.writeFileSync(filePath, lines.join('\n'));
+}

package/dist/commands/graph.d.ts

@@ -0,0 +1,5 @@
+export interface GraphResult {
+    nodeCount: number;
+    edgeCount: number;
+}
+export declare function graphCommand(graphDir: string): Promise<GraphResult>;

package/dist/commands/graph.js

@@ -0,0 +1,18 @@
+import { writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { loadGraph } from '../graph/loader.js';
+import { generateMermaid } from '../graph/mermaid.js';
+export async function graphCommand(graphDir) {
+    const graph = await loadGraph(graphDir);
+    const content = generateMermaid(graph);
+    writeFileSync(join(graphDir, '_graph.mmd'), content, 'utf-8');
+    let edgeCount = 0;
+    for (const node of graph.nodes.values()) {
+        for (const link of node.links) {
+            if (graph.nodes.has(link.target)) {
+                edgeCount++;
+            }
+        }
+    }
+    return { nodeCount: graph.nodes.size, edgeCount };
+}

package/dist/commands/health.d.ts

@@ -0,0 +1 @@
+export declare function healthCommand(targetPath: string | undefined): Promise<void>;

package/dist/commands/health.js

@@ -0,0 +1,36 @@
+import { resolveGraphDir } from '../graph/loader.js';
+import { getHealth } from '../graph/operations.js';
+import { NODE_TYPES } from '../graph/types.js';
+import { t } from '../i18n/index.js';
+export async function healthCommand(targetPath) {
+    const graphDir = resolveGraphDir(targetPath);
+    const report = await getHealth(graphDir);
+    const avgConf = report.avgConfidence !== null ? report.avgConfidence.toFixed(2) : 'N/A';
+    const linkDensity = report.linkDensity.toFixed(2);
+    // Output
+    console.log('');
+    console.log(`=== ${t('health.title')} ===`);
+    console.log('');
+    console.log(`${t('health.total_nodes')}: ${report.totalNodes}`);
+    console.log('');
+    console.log(`${t('health.by_type')}:`);
+    for (const nodeType of NODE_TYPES) {
+        const count = report.byType[nodeType] ?? 0;
+        if (count > 0) {
+            console.log(`  ${nodeType}: ${count}`);
+        }
+    }
+    const hypStatus = report.statusDistribution['hypothesis'];
+    if (hypStatus && Object.keys(hypStatus).length > 0) {
+        console.log('');
+        console.log(`${t('health.hypothesis_status')}:`);
+        for (const [status, count] of Object.entries(hypStatus).sort()) {
+            console.log(`  ${status}: ${count}`);
+        }
+    }
+    console.log('');
+    console.log(`${t('health.avg_confidence')}: ${avgConf}`);
+    console.log(`${t('health.open_questions')}: ${report.openQuestions}`);
+    console.log(`${t('health.link_density')}: ${linkDensity}`);
+    console.log('');
+}

package/dist/commands/index.d.ts

@@ -0,0 +1,4 @@
+export interface IndexResult {
+    nodeCount: number;
+}
+export declare function indexCommand(graphDir: string): Promise<IndexResult>;

package/dist/commands/index.js

@@ -0,0 +1,10 @@
+import { writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { loadGraph } from '../graph/loader.js';
+import { generateIndex } from '../graph/index-generator.js';
+export async function indexCommand(graphDir) {
+    const graph = await loadGraph(graphDir);
+    const content = generateIndex(graph);
+    writeFileSync(join(graphDir, '_index.md'), content, 'utf-8');
+    return { nodeCount: graph.nodes.size };
+}

package/dist/commands/init.d.ts

@@ -0,0 +1,4 @@
+export declare function initCommand(targetPath: string | undefined, options: {
+    lang?: string;
+    tool?: string;
+}): void;

package/dist/commands/init.js

@@ -0,0 +1,40 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { NODE_TYPE_DIRS } from '../graph/types.js';
+import { t } from '../i18n/index.js';
+import { generateRulesFile } from '../rules/generators.js';
+export function initCommand(targetPath, options) {
+    const target = path.resolve(targetPath ?? '.');
+    const graphDir = path.join(target, 'graph');
+    const configPath = path.join(target, '.emdd.yml');
+    const lang = options.lang ?? 'en';
+    const tool = options.tool ?? 'claude';
+    // Check if already initialized (graph dir check)
+    if (fs.existsSync(graphDir)) {
+        console.log(t('init.already_exists', { path: target }));
+    }
+    else {
+        // Create graph/ and all subdirectories
+        fs.mkdirSync(graphDir, { recursive: true });
+        for (const dir of Object.values(NODE_TYPE_DIRS)) {
+            fs.mkdirSync(path.join(graphDir, dir), { recursive: true });
+        }
+        // Create .emdd.yml config
+        const config = [
+            `lang: ${lang}`,
+            `version: "1.0"`,
+            '',
+        ].join('\n');
+        fs.writeFileSync(configPath, config, 'utf-8');
+        console.log(t('init.success', { path: target }));
+        console.log(t('init.next_steps'));
+    }
+    // Generate tool-specific rules files
+    const result = generateRulesFile(tool, target);
+    for (const created of result.created) {
+        console.log(`Created ${created}`);
+    }
+    for (const skipped of result.skipped) {
+        console.log(`Skipped (already exists): ${skipped}`);
+    }
+}

package/dist/commands/link.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Add a link from source node to target node with the given relation.
+ * Delegates to the pure operations.createEdge function.
+ */
+export declare function linkCommand(graphDir: string, source: string, target: string, relation: string): Promise<void>;

package/dist/commands/link.js

@@ -0,0 +1,8 @@
+import { createEdge } from '../graph/operations.js';
+/**
+ * Add a link from source node to target node with the given relation.
+ * Delegates to the pure operations.createEdge function.
+ */
+export async function linkCommand(graphDir, source, target, relation) {
+    await createEdge(graphDir, source, target, relation);
+}

package/dist/commands/lint.d.ts

@@ -0,0 +1 @@
+export declare function lintCommand(targetPath: string | undefined): Promise<void>;

package/dist/commands/lint.js

@@ -0,0 +1,27 @@
+import { resolveGraphDir, loadGraph } from '../graph/loader.js';
+import { lintGraph } from '../graph/validator.js';
+import { t } from '../i18n/index.js';
+export async function lintCommand(targetPath) {
+    const graphDir = resolveGraphDir(targetPath);
+    const graph = await loadGraph(graphDir);
+    const errors = lintGraph(graph);
+    const realErrors = errors.filter(e => e.severity === 'error');
+    const warnings = errors.filter(e => e.severity === 'warning');
+    if (realErrors.length === 0 && warnings.length === 0) {
+        console.log(t('lint.clean'));
+        return;
+    }
+    for (const err of realErrors) {
+        console.log(`ERROR  ${err.nodeId}  ${err.field}  ${err.message}`);
+    }
+    for (const warn of warnings) {
+        console.log(`WARN   ${warn.nodeId}  ${warn.field}  ${warn.message}`);
+    }
+    if (realErrors.length > 0) {
+        console.log(t('lint.errors_found', { count: String(realErrors.length) }));
+        process.exit(1);
+    }
+    if (warnings.length > 0) {
+        console.log(t('lint.warnings_found', { count: String(warnings.length) }));
+    }
+}

package/dist/commands/new.d.ts

@@ -0,0 +1,3 @@
+export declare function newCommand(type: string, slug: string, options: {
+    path?: string;
+}): Promise<void>;

package/dist/commands/new.js

@@ -0,0 +1,14 @@
+import { resolveGraphDir } from '../graph/loader.js';
+import { createNode } from '../graph/operations.js';
+import { NODE_TYPES } from '../graph/types.js';
+import { t } from '../i18n/index.js';
+export async function newCommand(type, slug, options) {
+    // Validate type early for user-facing error message
+    if (!NODE_TYPES.includes(type)) {
+        console.error(t('new.invalid_type', { type, valid: NODE_TYPES.join(', ') }));
+        process.exit(1);
+    }
+    const graphDir = resolveGraphDir(options.path);
+    const result = await createNode(graphDir, type, slug);
+    console.log(t('new.created', { type: result.type, id: result.id }));
+}

package/dist/commands/promote.d.ts

@@ -0,0 +1,9 @@
+import type { PromoteCandidate } from '../graph/types.js';
+export interface PromoteResult {
+    candidates: PromoteCandidate[];
+}
+/**
+ * Identify findings eligible for promotion to knowledge.
+ * Delegates to the pure operations.getPromotionCandidates function.
+ */
+export declare function promoteCommand(graphDir: string): Promise<PromoteResult>;

package/dist/commands/promote.js

@@ -0,0 +1,9 @@
+import { getPromotionCandidates } from '../graph/operations.js';
+/**
+ * Identify findings eligible for promotion to knowledge.
+ * Delegates to the pure operations.getPromotionCandidates function.
+ */
+export async function promoteCommand(graphDir) {
+    const candidates = await getPromotionCandidates(graphDir);
+    return { candidates };
+}