@narrative-os/cli 0.1.0

package/dist/commands/read.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readCommand = readCommand;
+const store_js_1 = require("../config/store.js");
+function readCommand(storyId, chapterNumber) {
+    const story = (0, store_js_1.loadStory)(storyId);
+    if (!story) {
+        console.error(`Story not found: ${storyId}`);
+        process.exit(1);
+    }
+    const { bible, chapters } = story;
+    if (chapters.length === 0) {
+        console.log(`Story "${bible.title}" has no chapters yet.`);
+        console.log(`Run "nos generate ${storyId}" to write Chapter 1.`);
+        return;
+    }
+    if (chapterNumber) {
+        // Read specific chapter
+        const chapter = chapters.find(ch => ch.number === chapterNumber);
+        if (!chapter) {
+            console.error(`Chapter ${chapterNumber} not found.`);
+            console.log(`Available chapters: 1-${chapters.length}`);
+            process.exit(1);
+        }
+        console.log(`\n# Chapter ${chapter.number}: ${chapter.title}`);
+        console.log(`Word count: ${chapter.wordCount}`);
+        console.log('─'.repeat(60));
+        console.log('');
+        console.log(chapter.content);
+        console.log('');
+        console.log('─'.repeat(60));
+    }
+    else {
+        // List all chapters
+        console.log(`\nStory: ${bible.title}`);
+        console.log(`Total chapters: ${chapters.length}\n`);
+        for (const chapter of chapters) {
+            console.log(`  Chapter ${chapter.number}: ${chapter.title} (${chapter.wordCount} words)`);
+        }
+        console.log(`\nUse "nos read ${storyId} <chapter-number>" to read a specific chapter.`);
+    }
+}

package/dist/commands/regenerate.d.ts

@@ -0,0 +1 @@
+export declare function regenerateCommand(storyId: string, chapterNumber: number): Promise<void>;

package/dist/commands/regenerate.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.regenerateCommand = regenerateCommand;
+const engine_1 = require("@narrative-os/engine");
+const store_js_1 = require("../config/store.js");
+async function regenerateCommand(storyId, chapterNumber) {
+    const story = (0, store_js_1.loadStory)(storyId);
+    if (!story) {
+        console.error(`Story not found: ${storyId}`);
+        process.exit(1);
+    }
+    const { bible, state, chapters, canon } = story;
+    // Find the chapter to regenerate
+    const chapterIndex = chapters.findIndex(ch => ch.number === chapterNumber);
+    if (chapterIndex === -1) {
+        console.error(`Chapter ${chapterNumber} not found.`);
+        console.log(`Available chapters: 1-${chapters.length}`);
+        process.exit(1);
+    }
+    console.log(`Regenerating Chapter ${chapterNumber}...`);
+    console.log(`Current title: ${chapters[chapterIndex].title}\n`);
+    // Load or initialize vector store
+    const vectorStore = (0, engine_1.getVectorStore)(storyId);
+    const existingData = (0, store_js_1.loadVectorStore)(storyId);
+    if (existingData) {
+        await vectorStore.load(existingData);
+    }
+    else {
+        await vectorStore.initialize();
+    }
+    // Create context - use state as it was BEFORE this chapter
+    const context = {
+        bible,
+        state: {
+            ...state,
+            currentChapter: chapterNumber - 1, // Pretend we're at previous chapter
+        },
+        chapterNumber,
+        targetWordCount: 1500,
+    };
+    try {
+        const result = await (0, engine_1.generateChapter)(context, { canon, vectorStore });
+        // Replace the old chapter
+        const newChapters = [...chapters];
+        newChapters[chapterIndex] = result.chapter;
+        (0, store_js_1.saveStory)(bible, state, newChapters, canon);
+        (0, store_js_1.saveVectorStore)(storyId, vectorStore.serialize());
+        console.log(`\n✅ Chapter ${chapterNumber} regenerated!`);
+        console.log(`New title: ${result.chapter.title}`);
+        console.log(`Words: ${result.chapter.wordCount}`);
+        if (result.violations.length > 0) {
+            console.log(`⚠️  Canon violations: ${result.violations.length}`);
+        }
+        console.log(`\nSummary: ${result.summary.summary}`);
+    }
+    catch (error) {
+        console.error('Regeneration failed:', error);
+        process.exit(1);
+    }
+}

package/dist/commands/state.d.ts

@@ -0,0 +1 @@
+export declare function stateCommand(storyId: string): void;

package/dist/commands/state.js

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.stateCommand = stateCommand;
+const store_js_1 = require("../config/store.js");
+function stateCommand(storyId) {
+    const story = (0, store_js_1.loadStory)(storyId);
+    const structuredState = (0, store_js_1.loadStructuredState)(storyId);
+    if (!story) {
+        console.error(`Story not found: ${storyId}`);
+        process.exit(1);
+    }
+    const { bible, state } = story;
+    console.log(`\n# Story State: ${bible.title}`);
+    console.log('─'.repeat(60));
+    console.log(`\n## Progress`);
+    console.log(`  Current Chapter: ${state.currentChapter} / ${state.totalChapters}`);
+    const progress = Math.round((state.currentChapter / state.totalChapters) * 100);
+    console.log(`  Progress: ${progress}%`);
+    console.log(`  Current Tension: ${(state.currentTension * 100).toFixed(0)}%`);
+    if (structuredState) {
+        console.log(`\n## Characters`);
+        console.log('─'.repeat(60));
+        const characters = Object.values(structuredState.characters);
+        if (characters.length === 0) {
+            console.log('  No character states tracked.');
+        }
+        else {
+            for (const char of characters) {
+                console.log(`\n  ${char.name}`);
+                console.log(`    Emotional State: ${char.emotionalState}`);
+                console.log(`    Location: ${char.location}`);
+                console.log(`    Goals: ${char.goals.join(', ')}`);
+                if (char.knowledge.length > 0) {
+                    console.log(`    Knowledge: ${char.knowledge.length} facts`);
+                }
+                if (Object.keys(char.relationships).length > 0) {
+                    console.log(`    Relationships: ${Object.entries(char.relationships).map(([k, v]) => `${k} (${v})`).join(', ')}`);
+                }
+            }
+        }
+        console.log(`\n## Plot Threads`);
+        console.log('─'.repeat(60));
+        const threads = Object.values(structuredState.plotThreads);
+        if (threads.length === 0) {
+            console.log('  No plot threads tracked.');
+        }
+        else {
+            for (const thread of threads) {
+                console.log(`\n  ${thread.name}`);
+                console.log(`    Status: ${thread.status}`);
+                console.log(`    Tension: ${(thread.tension * 100).toFixed(0)}%`);
+                console.log(`    Last Chapter: ${thread.lastChapter}`);
+                console.log(`    Summary: ${thread.summary.substring(0, 60)}...`);
+            }
+        }
+        if (structuredState.unresolvedQuestions.length > 0) {
+            console.log(`\n## Unresolved Questions`);
+            console.log('─'.repeat(60));
+            for (const q of structuredState.unresolvedQuestions) {
+                console.log(`  • ${q}`);
+            }
+        }
+        if (structuredState.recentEvents.length > 0) {
+            console.log(`\n## Recent Events`);
+            console.log('─'.repeat(60));
+            for (const e of structuredState.recentEvents.slice(-5)) {
+                console.log(`  • ${e.substring(0, 80)}...`);
+            }
+        }
+    }
+    else {
+        console.log('\n  No structured state available.');
+        console.log('  Generate some chapters to track state.');
+    }
+    console.log('');
+}

package/dist/commands/status.d.ts

@@ -0,0 +1 @@
+export declare function statusCommand(storyId?: string): void;

package/dist/commands/status.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.statusCommand = statusCommand;
+const store_js_1 = require("../config/store.js");
+function statusCommand(storyId) {
+    if (!storyId) {
+        const stories = (0, store_js_1.listStories)();
+        if (stories.length === 0) {
+            console.log('No stories found.\n');
+            console.log('💡 Get started:');
+            console.log('   • Create a new story:  nos init --title "My Story"');
+            console.log('   • Or with options:     nos init --help');
+            return;
+        }
+        console.log('Stories:\n');
+        for (const story of stories) {
+            const progress = Math.round((story.currentChapter / story.totalChapters) * 100);
+            console.log(`  ${story.id}`);
+            console.log(`    Title: ${story.title}`);
+            console.log(`    Progress: ${story.currentChapter}/${story.totalChapters} (${progress}%)`);
+            console.log('');
+        }
+        return;
+    }
+    const story = (0, store_js_1.loadStory)(storyId);
+    if (!story) {
+        console.error(`Story not found: ${storyId}`);
+        process.exit(1);
+    }
+    const { bible, state, chapters } = story;
+    const progress = Math.round((state.currentChapter / state.totalChapters) * 100);
+    console.log(`Story: ${bible.title}`);
+    console.log(`ID: ${bible.id}`);
+    console.log(`Theme: ${bible.theme}`);
+    console.log(`Genre: ${bible.genre}`);
+    console.log(`Setting: ${bible.setting}`);
+    console.log(`\nProgress: ${state.currentChapter}/${state.totalChapters} (${progress}%)`);
+    console.log(`Current Tension: ${(state.currentTension * 100).toFixed(0)}%`);
+    if (chapters.length > 0) {
+        console.log('\nChapters:');
+        for (const ch of chapters) {
+            console.log(`  ${ch.number}. ${ch.title} (${ch.wordCount} words)`);
+        }
+    }
+    if (state.chapterSummaries.length > 0) {
+        console.log('\nRecent Summaries:');
+        for (const sum of state.chapterSummaries.slice(-3)) {
+            console.log(`  Ch ${sum.chapterNumber}: ${sum.summary.substring(0, 80)}...`);
+        }
+    }
+}

package/dist/commands/validate.d.ts

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

package/dist/commands/validate.js

@@ -0,0 +1,93 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateCommand = validateCommand;
+const engine_1 = require("@narrative-os/engine");
+const store_js_1 = require("../config/store.js");
+async function validateCommand(storyId) {
+    const story = (0, store_js_1.loadStory)(storyId);
+    if (!story) {
+        console.error(`Story not found: ${storyId}`);
+        process.exit(1);
+    }
+    const { bible, state, chapters, canon, structuredState } = story;
+    console.log(`\nValidating Story: ${bible.title}`);
+    console.log('─'.repeat(60));
+    // Load constraint graph if exists
+    const constraintGraph = (0, engine_1.createConstraintGraph)();
+    const graphData = (0, store_js_1.loadConstraintGraph)(storyId);
+    if (graphData) {
+        constraintGraph.load(graphData);
+    }
+    // Load vector store if exists
+    const vectorStore = (0, engine_1.getVectorStore)(storyId);
+    const vectorData = (0, store_js_1.loadVectorStore)(storyId);
+    if (vectorData) {
+        await vectorStore.load(vectorData);
+    }
+    console.log(`\n## Story Statistics`);
+    console.log(`  Chapters: ${chapters.length} / ${state.totalChapters}`);
+    console.log(`  Canon Facts: ${canon.facts.length}`);
+    console.log(`  Constraint Graph: ${constraintGraph.getStats().nodes} nodes, ${constraintGraph.getStats().edges} edges`);
+    console.log(`  Vector Memories: ${vectorStore.getAllMemories().length}`);
+    // Validate each chapter
+    if (chapters.length > 0 && structuredState) {
+        console.log(`\n## Chapter Validation`);
+        console.log('─'.repeat(60));
+        const validator = new engine_1.Validator(constraintGraph);
+        let totalViolations = 0;
+        for (const chapter of chapters) {
+            const result = validator.quickValidate({
+                chapter,
+                bible,
+                structuredState,
+                canon,
+                previousChapters: chapters.filter(ch => ch.number < chapter.number),
+                constraintGraph,
+            });
+            const errors = result.violations.filter(v => v.severity === 'error').length;
+            const warnings = result.violations.filter(v => v.severity === 'warning').length;
+            if (errors > 0 || warnings > 0) {
+                console.log(`\n  Chapter ${chapter.number}: ${chapter.title}`);
+                if (errors > 0)
+                    console.log(`    ❌ ${errors} error(s)`);
+                if (warnings > 0)
+                    console.log(`    ⚠️  ${warnings} warning(s)`);
+                totalViolations += result.violations.length;
+            }
+        }
+        if (totalViolations === 0) {
+            console.log('  ✅ All chapters pass validation!');
+        }
+        else {
+            console.log(`\n  Total: ${totalViolations} violation(s) found`);
+        }
+    }
+    // Check for common issues
+    console.log(`\n## Consistency Checks`);
+    console.log('─'.repeat(60));
+    const issues = [];
+    // Check for chapters without summaries
+    const noSummary = chapters.filter(ch => !ch.summary || ch.summary.length < 10);
+    if (noSummary.length > 0) {
+        issues.push(`${noSummary.length} chapter(s) missing summaries`);
+    }
+    // Check for very short chapters
+    const shortChapters = chapters.filter(ch => ch.wordCount < 500);
+    if (shortChapters.length > 0) {
+        issues.push(`${shortChapters.length} chapter(s) unusually short (< 500 words)`);
+    }
+    // Check for canon facts without chapters
+    const orphanedFacts = canon.facts.filter(f => f.chapterEstablished > state.currentChapter);
+    if (orphanedFacts.length > 0) {
+        issues.push(`${orphanedFacts.length} canon fact(s) from future chapters`);
+    }
+    if (issues.length === 0) {
+        console.log('  ✅ No issues found!');
+    }
+    else {
+        for (const issue of issues) {
+            console.log(`  ⚠️  ${issue}`);
+        }
+    }
+    console.log('\n');
+}

package/dist/config/store.d.ts

@@ -0,0 +1,24 @@
+import type { StoryBible, StoryState, Chapter, CanonStore, StoryStructuredState } from '@narrative-os/engine';
+export declare function saveStory(bible: StoryBible, state: StoryState, chapters: Chapter[], canon?: CanonStore, structuredState?: StoryStructuredState): void;
+export declare function loadStory(storyId: string): {
+    bible: StoryBible;
+    state: StoryState;
+    chapters: Chapter[];
+    canon: CanonStore;
+    structuredState: StoryStructuredState | null;
+} | null;
+export declare function listStories(): {
+    id: string;
+    title: string;
+    currentChapter: number;
+    totalChapters: number;
+}[];
+export declare function saveVectorStore(storyId: string, data: string): void;
+export declare function loadVectorStore(storyId: string): string | null;
+export declare function saveStructuredState(storyId: string, state: StoryStructuredState): void;
+export declare function loadStructuredState(storyId: string): StoryStructuredState | null;
+export declare function initializeStructuredState(storyId: string, bible: StoryBible): StoryStructuredState;
+export declare function saveConstraintGraph(storyId: string, data: string): void;
+export declare function loadConstraintGraph(storyId: string): string | null;
+export declare function saveWorldState(storyId: string, data: string): void;
+export declare function loadWorldState(storyId: string): string | null;

package/dist/config/store.js

@@ -0,0 +1,183 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.saveStory = saveStory;
+exports.loadStory = loadStory;
+exports.listStories = listStories;
+exports.saveVectorStore = saveVectorStore;
+exports.loadVectorStore = loadVectorStore;
+exports.saveStructuredState = saveStructuredState;
+exports.loadStructuredState = loadStructuredState;
+exports.initializeStructuredState = initializeStructuredState;
+exports.saveConstraintGraph = saveConstraintGraph;
+exports.loadConstraintGraph = loadConstraintGraph;
+exports.saveWorldState = saveWorldState;
+exports.loadWorldState = loadWorldState;
+const fs_1 = require("fs");
+const path_1 = require("path");
+const os_1 = require("os");
+const engine_1 = require("@narrative-os/engine");
+const DATA_DIR = (0, path_1.join)((0, os_1.homedir)(), '.narrative-os');
+const STORIES_DIR = (0, path_1.join)(DATA_DIR, 'stories');
+function ensureDirs() {
+    if (!(0, fs_1.existsSync)(DATA_DIR))
+        (0, fs_1.mkdirSync)(DATA_DIR, { recursive: true });
+    if (!(0, fs_1.existsSync)(STORIES_DIR))
+        (0, fs_1.mkdirSync)(STORIES_DIR, { recursive: true });
+}
+function saveStory(bible, state, chapters, canon, structuredState) {
+    ensureDirs();
+    const storyDir = (0, path_1.join)(STORIES_DIR, bible.id);
+    if (!(0, fs_1.existsSync)(storyDir))
+        (0, fs_1.mkdirSync)(storyDir, { recursive: true });
+    (0, fs_1.writeFileSync)((0, path_1.join)(storyDir, 'bible.json'), JSON.stringify(bible, null, 2));
+    (0, fs_1.writeFileSync)((0, path_1.join)(storyDir, 'state.json'), JSON.stringify(state, null, 2));
+    (0, fs_1.writeFileSync)((0, path_1.join)(storyDir, 'chapters.json'), JSON.stringify(chapters, null, 2));
+    const canonToSave = canon || (0, engine_1.extractCanonFromBible)(bible);
+    (0, fs_1.writeFileSync)((0, path_1.join)(storyDir, 'canon.json'), JSON.stringify(canonToSave, null, 2));
+    // Save structured state if provided
+    if (structuredState) {
+        (0, fs_1.writeFileSync)((0, path_1.join)(storyDir, 'structured-state.json'), JSON.stringify(structuredState, null, 2));
+    }
+}
+function loadStory(storyId) {
+    const storyDir = (0, path_1.join)(STORIES_DIR, storyId);
+    if (!(0, fs_1.existsSync)(storyDir))
+        return null;
+    try {
+        const bible = JSON.parse((0, fs_1.readFileSync)((0, path_1.join)(storyDir, 'bible.json'), 'utf-8'));
+        const state = JSON.parse((0, fs_1.readFileSync)((0, path_1.join)(storyDir, 'state.json'), 'utf-8'));
+        const chapters = JSON.parse((0, fs_1.readFileSync)((0, path_1.join)(storyDir, 'chapters.json'), 'utf-8'));
+        let canon;
+        const canonPath = (0, path_1.join)(storyDir, 'canon.json');
+        if ((0, fs_1.existsSync)(canonPath)) {
+            canon = JSON.parse((0, fs_1.readFileSync)(canonPath, 'utf-8'));
+        }
+        else {
+            canon = (0, engine_1.extractCanonFromBible)(bible);
+        }
+        // Load structured state
+        let structuredState = null;
+        const structuredPath = (0, path_1.join)(storyDir, 'structured-state.json');
+        if ((0, fs_1.existsSync)(structuredPath)) {
+            structuredState = JSON.parse((0, fs_1.readFileSync)(structuredPath, 'utf-8'));
+        }
+        return { bible, state, chapters, canon, structuredState };
+    }
+    catch {
+        return null;
+    }
+}
+function listStories() {
+    ensureDirs();
+    const stories = [];
+    for (const dir of (0, fs_1.existsSync)(STORIES_DIR) ? (0, fs_1.readdirSync)(STORIES_DIR) : []) {
+        const storyPath = (0, path_1.join)(STORIES_DIR, dir);
+        const statePath = (0, path_1.join)(storyPath, 'state.json');
+        const biblePath = (0, path_1.join)(storyPath, 'bible.json');
+        if ((0, fs_1.existsSync)(statePath) && (0, fs_1.existsSync)(biblePath)) {
+            try {
+                const state = JSON.parse((0, fs_1.readFileSync)(statePath, 'utf-8'));
+                const bible = JSON.parse((0, fs_1.readFileSync)(biblePath, 'utf-8'));
+                stories.push({
+                    id: dir,
+                    title: bible.title,
+                    currentChapter: state.currentChapter,
+                    totalChapters: state.totalChapters,
+                });
+            }
+            catch { }
+        }
+    }
+    return stories;
+}
+// Vector store persistence
+function saveVectorStore(storyId, data) {
+    ensureDirs();
+    const storyDir = (0, path_1.join)(STORIES_DIR, storyId);
+    if (!(0, fs_1.existsSync)(storyDir))
+        (0, fs_1.mkdirSync)(storyDir, { recursive: true });
+    (0, fs_1.writeFileSync)((0, path_1.join)(storyDir, 'vector-store.json'), data);
+}
+function loadVectorStore(storyId) {
+    const storyDir = (0, path_1.join)(STORIES_DIR, storyId);
+    const vectorPath = (0, path_1.join)(storyDir, 'vector-store.json');
+    if (!(0, fs_1.existsSync)(vectorPath))
+        return null;
+    try {
+        return (0, fs_1.readFileSync)(vectorPath, 'utf-8');
+    }
+    catch {
+        return null;
+    }
+}
+// Structured state persistence
+function saveStructuredState(storyId, state) {
+    ensureDirs();
+    const storyDir = (0, path_1.join)(STORIES_DIR, storyId);
+    if (!(0, fs_1.existsSync)(storyDir))
+        (0, fs_1.mkdirSync)(storyDir, { recursive: true });
+    (0, fs_1.writeFileSync)((0, path_1.join)(storyDir, 'structured-state.json'), JSON.stringify(state, null, 2));
+}
+function loadStructuredState(storyId) {
+    const storyDir = (0, path_1.join)(STORIES_DIR, storyId);
+    const statePath = (0, path_1.join)(storyDir, 'structured-state.json');
+    if (!(0, fs_1.existsSync)(statePath))
+        return null;
+    try {
+        return JSON.parse((0, fs_1.readFileSync)(statePath, 'utf-8'));
+    }
+    catch {
+        return null;
+    }
+}
+// Initialize structured state from bible if it doesn't exist
+function initializeStructuredState(storyId, bible) {
+    let state = loadStructuredState(storyId);
+    if (!state) {
+        state = (0, engine_1.createStructuredState)(storyId);
+        state = (0, engine_1.initializeCharactersFromBible)(state, bible);
+        state = (0, engine_1.initializePlotThreadsFromBible)(state, bible);
+        saveStructuredState(storyId, state);
+    }
+    return state;
+}
+// Constraint graph persistence
+function saveConstraintGraph(storyId, data) {
+    ensureDirs();
+    const storyDir = (0, path_1.join)(STORIES_DIR, storyId);
+    if (!(0, fs_1.existsSync)(storyDir))
+        (0, fs_1.mkdirSync)(storyDir, { recursive: true });
+    (0, fs_1.writeFileSync)((0, path_1.join)(storyDir, 'constraint-graph.json'), data);
+}
+function loadConstraintGraph(storyId) {
+    const storyDir = (0, path_1.join)(STORIES_DIR, storyId);
+    const graphPath = (0, path_1.join)(storyDir, 'constraint-graph.json');
+    if (!(0, fs_1.existsSync)(graphPath))
+        return null;
+    try {
+        return (0, fs_1.readFileSync)(graphPath, 'utf-8');
+    }
+    catch {
+        return null;
+    }
+}
+// World state persistence
+function saveWorldState(storyId, data) {
+    ensureDirs();
+    const storyDir = (0, path_1.join)(STORIES_DIR, storyId);
+    if (!(0, fs_1.existsSync)(storyDir))
+        (0, fs_1.mkdirSync)(storyDir, { recursive: true });
+    (0, fs_1.writeFileSync)((0, path_1.join)(storyDir, 'world-state.json'), data);
+}
+function loadWorldState(storyId) {
+    const storyDir = (0, path_1.join)(STORIES_DIR, storyId);
+    const worldPath = (0, path_1.join)(storyDir, 'world-state.json');
+    if (!(0, fs_1.existsSync)(worldPath))
+        return null;
+    try {
+        return (0, fs_1.readFileSync)(worldPath, 'utf-8');
+    }
+    catch {
+        return null;
+    }
+}

package/dist/index.d.ts

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

package/dist/index.js

@@ -0,0 +1,130 @@
+#!/usr/bin/env node
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const commander_1 = require("commander");
+const init_js_1 = require("./commands/init.js");
+const generate_js_1 = require("./commands/generate.js");
+const status_js_1 = require("./commands/status.js");
+const config_js_1 = require("./commands/config.js");
+const list_js_1 = require("./commands/list.js");
+const delete_js_1 = require("./commands/delete.js");
+const clone_js_1 = require("./commands/clone.js");
+const export_js_1 = require("./commands/export.js");
+const read_js_1 = require("./commands/read.js");
+const bible_js_1 = require("./commands/bible.js");
+const state_js_1 = require("./commands/state.js");
+const hint_js_1 = require("./commands/hint.js");
+(0, config_js_1.applyConfig)();
+const program = new commander_1.Command();
+program
+    .name('nos')
+    .description('Narrative OS - AI-powered story generation')
+    .version('0.1.0');
+// Show welcome when no args provided
+if (process.argv.length <= 2) {
+    (0, hint_js_1.showWelcome)();
+    process.exit(0);
+}
+// Configuration
+program
+    .command('config')
+    .description('Configure LLM provider and API key')
+    .action(config_js_1.configCommand);
+// Story Management
+program
+    .command('init')
+    .description('Create a new story')
+    .option('-t, --title <title>', 'Story title')
+    .option('--theme <theme>', 'Story theme')
+    .option('-g, --genre <genre>', 'Genre')
+    .option('-s, --setting <setting>', 'Setting')
+    .option('--tone <tone>', 'Tone')
+    .option('-p, --premise <premise>', 'Story premise')
+    .option('-c, --chapters <number>', 'Target chapter count', '5')
+    .action(init_js_1.initCommand);
+program
+    .command('list')
+    .alias('ls')
+    .description('List all stories')
+    .action(list_js_1.listCommand);
+program
+    .command('status [story-id]')
+    .description('Show story status (or list all stories)')
+    .action(status_js_1.statusCommand);
+program
+    .command('delete <story-id>')
+    .description('Delete a story')
+    .option('-f, --force', 'Skip confirmation')
+    .action((storyId, options) => {
+    (0, delete_js_1.deleteCommand)(storyId, options.force);
+});
+program
+    .command('clone <story-id> <new-title>')
+    .description('Clone a story as a template')
+    .action(clone_js_1.cloneCommand);
+// Generation
+program
+    .command('generate <story-id>')
+    .alias('gen')
+    .description('Generate the next chapter')
+    .action(generate_js_1.generateCommand);
+program
+    .command('continue <story-id>')
+    .description('Generate all remaining chapters')
+    .action(async (storyId) => {
+    const { continueCommand } = await import('./commands/continue.js');
+    await continueCommand(storyId);
+});
+program
+    .command('regenerate <story-id> <chapter-number>')
+    .alias('regen')
+    .description('Regenerate a specific chapter')
+    .action(async (storyId, chapterNum) => {
+    const { regenerateCommand } = await import('./commands/regenerate.js');
+    await regenerateCommand(storyId, parseInt(chapterNum));
+});
+// Reading & Export
+program
+    .command('read <story-id> [chapter-number]')
+    .description('Read chapter content (or list chapters)')
+    .action((storyId, chapterNum) => {
+    (0, read_js_1.readCommand)(storyId, chapterNum ? parseInt(chapterNum) : undefined);
+});
+program
+    .command('export <story-id>')
+    .description('Export story to file')
+    .option('-f, --format <format>', 'Export format (markdown|txt)', 'markdown')
+    .option('-o, --output <file>', 'Output filename')
+    .action((storyId, options) => {
+    (0, export_js_1.exportCommand)(storyId, options.format, options.output);
+});
+// Bible & State
+program
+    .command('bible <story-id>')
+    .description('View story bible (characters, setting, etc.)')
+    .action(bible_js_1.bibleCommand);
+program
+    .command('state <story-id>')
+    .description('View structured story state')
+    .action(state_js_1.stateCommand);
+program
+    .command('memories <story-id> [query]')
+    .description('Search narrative memories')
+    .action(async (storyId, query) => {
+    const { memoriesCommand } = await import('./commands/memories.js');
+    await memoriesCommand(storyId, query);
+});
+program
+    .command('validate <story-id>')
+    .description('Validate story consistency')
+    .action(async (storyId) => {
+    const { validateCommand } = await import('./commands/validate.js');
+    await validateCommand(storyId);
+});
+program
+    .command('hint [story-id]')
+    .description('Show helpful hints and suggestions')
+    .action((storyId) => {
+    (0, hint_js_1.showHint)({ storyId });
+});
+program.parse();