@dnai/dynamicllm 0.1.1 → 0.2.1

package/README.md

@@ -0,0 +1,64 @@
+# DynamicLLM
+
+Perspective engine for general intelligence. MCP server + CLI providing three analysis modes for any text.
+
+## Modes
+
+- **Lens Analysis** — Evaluate balance between Logos (logic), Pathos (emotion), and their synthesis Mythos
+- **Quality Cultivation** — Develop one of six qualities: Play, Beauty, Mystery, Love, Infinity, Story
+- **Virus Scan** — Detect memetic patterns across six axes from Liberated Agentism to Oxidative Creativism
+
+## Install
+
+```bash
+npm i -g @dnai/dynamicllm && dynamicllm init
+```
+
+This installs the CLI and walks you through agent registration (Claude Code, Cursor, Windsurf, Codex).
+
+CLI commands work immediately without `init` — defaults are created on first use.
+
+## Quick Start
+
+```bash
+# Or register manually with Claude Code
+claude mcp add --scope user dynamicllm -- dynamicllm mcp
+```
+
+## CLI
+
+```bash
+dynamicllm help              # Show all commands
+dynamicllm list              # List all network nodes
+dynamicllm search <query>    # Search the network
+dynamicllm load <slug>       # Load a node's content
+dynamicllm lint              # Validate network integrity
+dynamicllm ingest <name>     # Generate frontmatter for a new node
+dynamicllm save <slug> <file>  # Save a node to your local network
+dynamicllm report <mode>     # Generate an analysis report
+dynamicllm log               # View activity log
+dynamicllm mcp               # Start MCP server (stdio transport)
+```
+
+## Architecture
+
+Content is organized in three layers:
+
+1. **Framework** (bundled) — System prompt, conventions, 3 lenses, 6 qualities, 6 antidotes in `framework/`
+2. **User Network** (local) — Your nodes in `DYNAMICLLM_NETWORK_DIR`, managed via CLI or MCP
+3. **DNA Network** (optional) — Curated thinker profiles deployed to R2 for the web demo
+
+Framework slugs are protected — user files cannot override bundled content.
+
+```
+framework/
+  SYSTEM_PROMPT.md
+  CONVENTIONS.md
+  lenses/       logos.md, pathos.md, mythos.md
+  qualities/    play.md, beauty.md, story.md, infinity.md, mystery.md, love.md
+  antidotes/    liberated-agentism.md, constructive-optimism.md, ...
+```
+
+## License
+
+MIT

package/dist/bin/dynamicllm.js

@@ -0,0 +1,7 @@
+#!/usr/bin/env node
+import { runCli } from "../cli/index.js";
+const args = process.argv.slice(2);
+runCli(args).catch((error) => {
+    console.error("Fatal error:", error instanceof Error ? error.message : error);
+    process.exit(1);
+});

package/dist/cli/formatters.d.ts

@@ -0,0 +1,11 @@
+import type { SearchResult, LintReport, LogEntry } from "../core/types.js";
+export declare function formatHelp(): string;
+export declare function formatSearchResults(results: SearchResult[]): string;
+export declare function formatNodeList(entries: {
+    slug: string;
+    displayName: string;
+    type: string;
+    tags: string[];
+}[]): string;
+export declare function formatLintReport(report: LintReport): string;
+export declare function formatLogEntries(entries: LogEntry[]): string;

package/dist/cli/formatters.js

@@ -0,0 +1,138 @@
+const BOLD = "\x1b[1m";
+const DIM = "\x1b[2m";
+const RESET = "\x1b[0m";
+const GREEN = "\x1b[32m";
+const YELLOW = "\x1b[33m";
+const RED = "\x1b[31m";
+const CYAN = "\x1b[36m";
+export function formatHelp() {
+    return `
+${BOLD}DynamicLLM${RESET} — perspective engine for general intelligence
+
+${BOLD}USAGE${RESET}
+  dynamicllm <command> [options]
+
+${BOLD}COMMANDS${RESET}
+  ${CYAN}mcp${RESET}                       Start MCP server (for AI tool registration)
+  ${CYAN}init${RESET}                      Interactive setup (Claude Code, Cursor, Windsurf, Codex)
+  ${CYAN}search${RESET} <query>            Search network by tags/names
+  ${CYAN}load${RESET} <slug>               Display a node's content
+  ${CYAN}list${RESET} [--type=X]           List all nodes
+  ${CYAN}lint${RESET}                      Validate network health
+  ${CYAN}ingest${RESET}                    Format content as v5-conformant node (interactive)
+  ${CYAN}save${RESET} <slug> <file>        Persist a node to local network
+  ${CYAN}source-search${RESET} <query>     Search within source works
+  ${CYAN}source-excerpt${RESET} <slug> <q> Retrieve passage from a source
+  ${CYAN}report${RESET}                    Generate styled analysis report
+  ${CYAN}log${RESET} [--limit=N]           View activity log
+
+${BOLD}ENVIRONMENT${RESET}
+  DYNAMICLLM_NETWORK_DIR    Path to user's network directory (default: ~/.dynamicllm/network/)
+
+${BOLD}EXAMPLES${RESET}
+  ${DIM}# Start MCP server for Claude Code${RESET}
+  dynamicllm mcp
+
+  ${DIM}# Search for nodes about epistemology${RESET}
+  dynamicllm search epistemology
+
+  ${DIM}# Load a specific thinker${RESET}
+  dynamicllm load david-deutsch
+
+  ${DIM}# List all antidotes${RESET}
+  dynamicllm list --type=antidote
+
+  ${DIM}# Run network health check${RESET}
+  dynamicllm lint
+
+  ${DIM}# Register with Claude Code${RESET}
+  dynamicllm init
+`;
+}
+export function formatSearchResults(results) {
+    if (results.length === 0)
+        return `${DIM}No results found.${RESET}`;
+    const lines = [`${BOLD}${results.length} result(s):${RESET}`, ""];
+    for (const r of results) {
+        const typeLabel = `[${r.type}]`.padEnd(12);
+        lines.push(`  ${CYAN}${r.slug}${RESET}  ${DIM}${typeLabel}${RESET}  ${r.displayName}  ${DIM}(score: ${r.score})${RESET}`);
+        if (r.tags.length > 0) {
+            lines.push(`    ${DIM}tags: ${r.tags.slice(0, 8).join(", ")}${r.tags.length > 8 ? ", ..." : ""}${RESET}`);
+        }
+    }
+    return lines.join("\n");
+}
+export function formatNodeList(entries) {
+    if (entries.length === 0)
+        return `${DIM}No nodes found.${RESET}`;
+    const lines = [`${BOLD}${entries.length} node(s):${RESET}`, ""];
+    // Group by type
+    const byType = new Map();
+    for (const e of entries) {
+        const list = byType.get(e.type) ?? [];
+        list.push(e);
+        byType.set(e.type, list);
+    }
+    for (const [type, items] of byType) {
+        lines.push(`  ${BOLD}${type}${RESET} (${items.length})`);
+        for (const item of items) {
+            lines.push(`    ${CYAN}${item.slug}${RESET}  ${DIM}${item.displayName}${RESET}`);
+        }
+        lines.push("");
+    }
+    return lines.join("\n");
+}
+export function formatLintReport(report) {
+    const lines = [];
+    lines.push(`${BOLD}Network Health Report${RESET}`);
+    lines.push(`${"─".repeat(40)}`);
+    lines.push(`  Total nodes: ${report.stats.totalNodes}`);
+    for (const [type, count] of Object.entries(report.stats.byType)) {
+        lines.push(`  ${type}: ${count}`);
+    }
+    lines.push("");
+    if (report.errors.length > 0) {
+        lines.push(`${RED}${BOLD}Errors (${report.errors.length}):${RESET}`);
+        for (const e of report.errors) {
+            lines.push(`  ${RED}✗${RESET} ${CYAN}${e.slug}${RESET}: ${e.message}`);
+        }
+        lines.push("");
+    }
+    if (report.warnings.length > 0) {
+        lines.push(`${YELLOW}${BOLD}Warnings (${report.warnings.length}):${RESET}`);
+        for (const w of report.warnings) {
+            lines.push(`  ${YELLOW}!${RESET} ${CYAN}${w.slug}${RESET}: ${w.message}`);
+        }
+        lines.push("");
+    }
+    if (report.tensions.length > 0) {
+        lines.push(`${GREEN}${BOLD}Productive Tensions (${report.tensions.length}):${RESET}`);
+        for (const t of report.tensions) {
+            lines.push(`  ${GREEN}⟷${RESET} ${t.description}`);
+            lines.push(`    ${DIM}shared: ${t.sharedTags.join(", ")}${RESET}`);
+        }
+        lines.push("");
+    }
+    if (report.stats.orphanTags.length > 0) {
+        lines.push(`${DIM}Orphan tags (used by only 1 node): ${report.stats.orphanTags.slice(0, 10).join(", ")}${report.stats.orphanTags.length > 10 ? `, ... (${report.stats.orphanTags.length} total)` : ""}${RESET}`);
+    }
+    const status = report.errors.length === 0
+        ? `${GREEN}${BOLD}Network healthy${RESET}`
+        : `${RED}${BOLD}${report.errors.length} error(s) found${RESET}`;
+    lines.push("");
+    lines.push(status);
+    return lines.join("\n");
+}
+export function formatLogEntries(entries) {
+    if (entries.length === 0)
+        return `${DIM}No activity log entries.${RESET}`;
+    const lines = [`${BOLD}Activity Log (${entries.length} entries):${RESET}`, ""];
+    for (const e of entries) {
+        const modeStr = e.mode ? ` ${DIM}[${e.mode}]${RESET}` : "";
+        lines.push(`  ${DIM}${e.date}${RESET}  ${CYAN}${e.action}${RESET}  ${e.slug}${modeStr}`);
+        if (e.summary) {
+            lines.push(`    ${DIM}${e.summary}${RESET}`);
+        }
+    }
+    return lines.join("\n");
+}

package/dist/cli/index.d.ts

@@ -0,0 +1 @@
+export declare function runCli(args: string[]): Promise<void>;

package/dist/cli/index.js

@@ -0,0 +1,345 @@
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { NetworkFetcher, FRAMEWORK_SLUGS } from "../core/fetcher.js";
+import { bootstrap } from "../core/bootstrap.js";
+import { search } from "../core/search.js";
+import { lint } from "../core/lint.js";
+import { generateReport } from "../core/report.js";
+import { appendLog, readLog } from "../core/log.js";
+import { formatHelp, formatSearchResults, formatNodeList, formatLintReport, formatLogEntries, } from "./formatters.js";
+function createFetcher(hint) {
+    const { networkDir, created } = bootstrap();
+    if (hint && created) {
+        process.stderr.write("DynamicLLM: created default config. Run `dynamicllm init` to customize.\n");
+    }
+    return new NetworkFetcher({ networkDir });
+}
+/** Parse --key=value flags from argv */
+function parseFlags(args) {
+    const flags = {};
+    const positional = [];
+    for (const arg of args) {
+        if (arg.startsWith("--")) {
+            const eq = arg.indexOf("=");
+            if (eq > 0) {
+                flags[arg.slice(2, eq)] = arg.slice(eq + 1);
+            }
+            else {
+                flags[arg.slice(2)] = "true";
+            }
+        }
+        else {
+            positional.push(arg);
+        }
+    }
+    return { flags, positional };
+}
+export async function runCli(args) {
+    const command = args[0];
+    const restArgs = args.slice(1);
+    const { flags, positional } = parseFlags(restArgs);
+    switch (command) {
+        case "mcp": {
+            const { startServer } = await import("../mcp/server.js");
+            await startServer();
+            break;
+        }
+        case "init": {
+            const { init } = await import("./init.js");
+            await init();
+            break;
+        }
+        case "search": {
+            const query = positional.join(" ");
+            if (!query) {
+                console.error("Usage: dynamicllm search <query> [--type=X] [--limit=N]");
+                process.exit(1);
+            }
+            const fetcher = createFetcher(true);
+            const index = await fetcher.fetchIndex();
+            const types = flags.type ? [flags.type] : undefined;
+            const limit = flags.limit ? parseInt(flags.limit, 10) : 10;
+            const results = search(index, query, { types, limit });
+            console.log(formatSearchResults(results));
+            break;
+        }
+        case "load": {
+            const slug = positional[0];
+            if (!slug) {
+                console.error("Usage: dynamicllm load <slug>");
+                process.exit(1);
+            }
+            const fetcher = createFetcher(true);
+            const index = await fetcher.fetchIndex();
+            const isNode = index.nodes.some((n) => n.slug === slug);
+            const isSource = index.sources.some((s) => s.slug === slug);
+            const isMeta = index.meta.some((m) => m.slug === slug);
+            let content;
+            if (isNode) {
+                content = await fetcher.fetchNode(slug);
+            }
+            else if (isSource) {
+                content = await fetcher.fetchSource(slug);
+            }
+            else if (isMeta) {
+                content = await fetcher.fetchMeta(slug);
+            }
+            else {
+                console.error(`Node '${slug}' not found in the DynamicLLM network.`);
+                process.exit(1);
+            }
+            console.log(content);
+            break;
+        }
+        case "list": {
+            const fetcher = createFetcher(true);
+            const index = await fetcher.fetchIndex();
+            let entries = [
+                ...index.nodes.map((n) => ({
+                    slug: n.slug,
+                    displayName: n.displayName,
+                    type: n.type,
+                    tags: n.tags,
+                })),
+                ...index.sources.map((s) => ({
+                    slug: s.slug,
+                    displayName: s.displayName,
+                    type: s.type,
+                    tags: s.tags,
+                })),
+            ];
+            if (flags.type) {
+                entries = entries.filter((e) => e.type === flags.type);
+            }
+            console.log(formatNodeList(entries));
+            break;
+        }
+        case "lint": {
+            const fetcher = createFetcher(true);
+            const index = await fetcher.fetchIndex();
+            const report = lint(index);
+            appendLog("lint", "network", { summary: `Errors: ${report.errors.length}, Warnings: ${report.warnings.length}` });
+            console.log(formatLintReport(report));
+            process.exit(report.errors.length > 0 ? 1 : 0);
+            break;
+        }
+        case "ingest": {
+            // Interactive ingest — read from stdin or provided arguments
+            const type = flags.type;
+            const name = positional[0] || flags.name;
+            if (!type || !name) {
+                console.error("Usage: dynamicllm ingest <name> --type=<type> [--tags=a,b,c] [--mind_virus=X] [--derived_from=a,b]");
+                console.error("  Reads content from stdin.");
+                console.error("  Types: person, idea, antidote, lens, quality, source, synthesis");
+                process.exit(1);
+            }
+            // Read content from stdin
+            const chunks = [];
+            for await (const chunk of process.stdin) {
+                chunks.push(chunk);
+            }
+            const content = Buffer.concat(chunks).toString("utf-8").trim();
+            if (!content) {
+                console.error("No content provided on stdin.");
+                process.exit(1);
+            }
+            const slug = name
+                .toLowerCase()
+                .replace(/[^a-z0-9]+/g, "-")
+                .replace(/^-|-$/g, "");
+            const tags = flags.tags?.split(",").map((t) => t.trim()).filter(Boolean) ?? [];
+            let frontmatter = `---\ntype: ${type}\nname: ${name}\n`;
+            if (type === "antidote" && flags.mind_virus) {
+                frontmatter += `mind_virus: ${flags.mind_virus}\n`;
+            }
+            if (tags.length > 0) {
+                frontmatter += `tags: [${tags.join(", ")}]\n`;
+            }
+            if (type === "synthesis" && flags.derived_from) {
+                const derived = flags.derived_from.split(",").map((s) => s.trim()).filter(Boolean);
+                frontmatter += `derived_from: [${derived.join(", ")}]\n`;
+            }
+            frontmatter += "---\n\n";
+            const output = `${frontmatter}# ${name}\n\n${content}`;
+            appendLog("ingest", slug, { summary: `Type: ${type}` });
+            console.log(output);
+            break;
+        }
+        case "save": {
+            const slug = positional[0];
+            const filePath = positional[1];
+            if (!slug || !filePath) {
+                console.error("Usage: dynamicllm save <slug> <file>");
+                console.error("  Or pipe content: echo '...' | dynamicllm save <slug> --stdin");
+                process.exit(1);
+            }
+            const { networkDir, created } = bootstrap();
+            if (created) {
+                process.stderr.write("DynamicLLM: created default config. Run `dynamicllm init` to customize.\n");
+            }
+            if (FRAMEWORK_SLUGS.has(slug)) {
+                console.error(`Error: "${slug}" is a protected framework slug and cannot be overridden.`);
+                process.exit(1);
+            }
+            const { mkdirSync, writeFileSync } = await import("node:fs");
+            if (!existsSync(networkDir)) {
+                mkdirSync(networkDir, { recursive: true });
+            }
+            let content;
+            if (flags.stdin === "true") {
+                const chunks = [];
+                for await (const chunk of process.stdin) {
+                    chunks.push(chunk);
+                }
+                content = Buffer.concat(chunks).toString("utf-8");
+            }
+            else {
+                if (!existsSync(filePath)) {
+                    console.error(`File not found: ${filePath}`);
+                    process.exit(1);
+                }
+                content = readFileSync(filePath, "utf-8");
+            }
+            const savePath = join(networkDir, `${slug}.md`);
+            writeFileSync(savePath, content, "utf-8");
+            appendLog("save", slug, { summary: `Saved: ${slug}.md` });
+            console.log(`Saved ${slug}.md to ${savePath}`);
+            break;
+        }
+        case "source-search": {
+            const query = positional.join(" ");
+            if (!query) {
+                console.error("Usage: dynamicllm source-search <query> [--source=slug] [--limit=N]");
+                process.exit(1);
+            }
+            const fetcher = createFetcher(true);
+            const index = await fetcher.fetchIndex();
+            if (index.sources.length === 0) {
+                console.log("No source works are available in the network yet.");
+                break;
+            }
+            const sources = flags.source
+                ? index.sources.filter((s) => s.slug === flags.source)
+                : index.sources;
+            const queryLower = query.toLowerCase();
+            const maxResults = flags.limit ? parseInt(flags.limit, 10) : 5;
+            const results = [];
+            for (const source of sources) {
+                if (results.length >= maxResults)
+                    break;
+                const content = await fetcher.fetchSource(source.slug);
+                const lines = content.split("\n");
+                for (let i = 0; i < lines.length; i++) {
+                    if (results.length >= maxResults)
+                        break;
+                    if (lines[i].toLowerCase().includes(queryLower)) {
+                        const start = Math.max(0, i - 2);
+                        const end = Math.min(lines.length, i + 3);
+                        results.push({
+                            source: source.displayName,
+                            excerpt: lines.slice(start, end).join("\n"),
+                        });
+                    }
+                }
+            }
+            if (results.length === 0) {
+                console.log(`No matches found for "${query}" in source works.`);
+            }
+            else {
+                for (const r of results) {
+                    console.log(`\n\x1b[1m${r.source}\x1b[0m`);
+                    console.log(r.excerpt);
+                }
+            }
+            break;
+        }
+        case "source-excerpt": {
+            const sourceSlug = positional[0];
+            const query = positional.slice(1).join(" ");
+            if (!sourceSlug || !query) {
+                console.error("Usage: dynamicllm source-excerpt <slug> <query>");
+                process.exit(1);
+            }
+            const fetcher = createFetcher(true);
+            const index = await fetcher.fetchIndex();
+            const source = index.sources.find((s) => s.slug === sourceSlug);
+            if (!source) {
+                console.error(`Source '${sourceSlug}' not found.`);
+                process.exit(1);
+            }
+            const content = await fetcher.fetchSource(sourceSlug);
+            const lines = content.split("\n");
+            const queryLower = query.toLowerCase();
+            let found = false;
+            for (let i = 0; i < lines.length; i++) {
+                if (lines[i].toLowerCase().includes(queryLower)) {
+                    const start = Math.max(0, i - 5);
+                    const end = Math.min(lines.length, i + 10);
+                    console.log(`\n\x1b[1m${source.displayName}\x1b[0m (around line ${i + 1}):\n`);
+                    console.log(lines.slice(start, end).join("\n"));
+                    found = true;
+                    break;
+                }
+            }
+            if (!found) {
+                console.log(`No passage matching "${query}" found in ${source.displayName}.`);
+            }
+            break;
+        }
+        case "report": {
+            const mode = flags.mode;
+            if (!mode) {
+                console.error("Usage: dynamicllm report --mode=<virus-scan|lens|quality>");
+                console.error("  Reads analysis text from stdin.");
+                process.exit(1);
+            }
+            const chunks = [];
+            for await (const chunk of process.stdin) {
+                chunks.push(chunk);
+            }
+            const analysisText = Buffer.concat(chunks).toString("utf-8").trim();
+            if (!analysisText) {
+                console.error("No analysis text provided on stdin.");
+                process.exit(1);
+            }
+            // Parse scores from --scores flag if provided (JSON string)
+            let scores;
+            if (flags.scores) {
+                try {
+                    scores = JSON.parse(flags.scores);
+                }
+                catch {
+                    console.error("Invalid --scores JSON.");
+                    process.exit(1);
+                }
+            }
+            const result = generateReport({
+                mode,
+                analysisText,
+                contentLabel: flags.label,
+                quality: flags.quality,
+                scores,
+            });
+            appendLog("report", mode, { summary: `Report: ${result.filePath}` });
+            console.log(`Report saved to: ${result.filePath}`);
+            break;
+        }
+        case "log": {
+            const limit = flags.limit ? parseInt(flags.limit, 10) : 20;
+            const action = flags.action;
+            const entries = readLog({ limit, action });
+            console.log(formatLogEntries(entries));
+            break;
+        }
+        case "help":
+        case "--help":
+        case "-h":
+        case undefined:
+            console.log(formatHelp());
+            break;
+        default:
+            console.error(`Unknown command: ${command}`);
+            console.error("Run 'dynamicllm help' for available commands.");
+            process.exit(1);
+    }
+}

package/dist/cli/init.d.ts

@@ -0,0 +1 @@
+export declare function init(): Promise<void>;