@doquflow/cli 0.2.0 → 0.4.0

package/dist/commands/init-interactive.js

@@ -0,0 +1,346 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runInteractive = runInteractive;
+const node_fs_1 = __importDefault(require("node:fs"));
+const promises_1 = __importDefault(require("node:fs/promises"));
+const node_path_1 = __importDefault(require("node:path"));
+const node_readline_1 = __importDefault(require("node:readline"));
+const init_1 = require("./init");
+async function prompt(question) {
+    const rl = node_readline_1.default.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+    });
+    return new Promise((resolve) => {
+        rl.question(question, (answer) => {
+            rl.close();
+            resolve(answer);
+        });
+    });
+}
+async function selectDomain() {
+    console.log("\n📚 What domain is your wiki for?");
+    console.log("  1) Code & Architecture");
+    console.log("  2) Research & Analysis");
+    console.log("  3) Business & Markets");
+    console.log("  4) Personal Knowledge");
+    let selection = "";
+    while (!["1", "2", "3", "4"].includes(selection)) {
+        selection = await prompt("Select (1-4): ");
+    }
+    const domains = {
+        "1": "code",
+        "2": "research",
+        "3": "business",
+        "4": "personal",
+    };
+    return domains[selection];
+}
+async function getProjectInfo(domain) {
+    console.log(`\n📝 Tell me about your ${domain} wiki`);
+    const name = await prompt("Project name (e.g., 'MyProject', 'Research2026'): ");
+    const description = await prompt("Brief description (what will this wiki track?): ");
+    return { name, description };
+}
+function getSchemaForDomain(domain) {
+    const schemas = {
+        code: `# Docuflow Wiki Schema - Code/Architecture
+
+## Domain
+Architecture and codebase documentation.
+
+## Wiki Structure
+
+### Entities (entities/)
+- Services: key microservices and components
+- APIs: public interfaces and endpoints  
+- Databases: data models and schemas
+- Frameworks: libraries and tools used
+
+### Concepts (concepts/)
+- Design Patterns: architectural and coding patterns
+- Principles: design principles and guidelines
+- Integrations: how components work together
+- Configuration: important settings and options
+
+### Syntheses (syntheses/)
+- Architecture Overview: system design
+- Decision Records: design decisions
+- Deployment Guide: how to deploy
+- API Reference: complete API docs
+
+### Timelines (timelines/)
+- Version History: evolution of the system
+- Roadmap: planned changes
+
+## Cross-Reference Patterns
+- "integrates with" - components/services that work together
+- "implemented by" - which entities implement a concept
+- "uses pattern" - which architecture patterns apply
+- "depends on" - dependencies between components
+
+## Metadata
+Each page should include:
+- created_at: when first documented
+- updated_at: last update date
+- tech_stack: relevant technologies
+- contributors: who wrote/contributed
+`,
+        research: `# Docuflow Wiki Schema - Research
+
+## Domain
+Research findings and analysis.
+
+## Wiki Structure
+
+### Entities (entities/)
+- Papers: academic papers and articles
+- Researchers: key people in the field
+- Conferences: important venues
+- Datasets: data sources used
+
+### Concepts (concepts/)
+- Methodologies: research methods
+- Theories: key theories and frameworks
+- Open Problems: unsolved questions
+- Keywords: important terms
+
+### Syntheses (syntheses/)
+- Literature Review: synthesis of papers
+- Findings: key discoveries
+- Future Work: research directions
+- Contradictions: areas of disagreement
+
+### Timelines (timelines/)
+- Research Evolution: how field evolved
+- Timeline of Discoveries: key milestones
+
+## Cross-Reference Patterns
+- "cites" - references between papers
+- "extends" - builds on prior work
+- "contradicts" - disagreement between sources
+- "validates" - experimental confirmation
+- "relates to" - topical connection
+
+## Metadata
+Each page should include:
+- created_at: when added
+- updated_at: last refresh
+- sources: which papers/sources
+- citations: number of times cited
+- confidence: how confident in findings
+`,
+        business: `# Docuflow Wiki Schema - Business
+
+## Domain
+Business and competitive analysis.
+
+## Wiki Structure
+
+### Entities (entities/)
+- Companies: competitors and partners
+- Products: key offerings
+- Markets: market segments
+- Customers: customer types
+
+### Concepts (concepts/)
+- Business Models: how companies make money
+- Market Segments: addressable markets
+- Capabilities: key competitive advantages
+- Trends: market trends
+
+### Syntheses (syntheses/)
+- Competitive Analysis: comparison matrix
+- Market Overview: market positioning
+- Opportunities: growth opportunities
+- Risks: market risks
+
+### Timelines (timelines/)
+- Market Evolution: how market changed
+- Competitive Timeline: competitor moves
+
+## Cross-Reference Patterns
+- "competes with" - direct competitors
+- "targets" - goes after customer/market
+- "partners with" - partnerships
+- "disrupts" - disruption threat
+- "complements" - complementary products
+
+## Metadata
+Each page should include:
+- created_at: when first documented
+- updated_at: last update
+- market_size: TAM/SAM/SOM if known
+- growth_rate: annual growth
+- sources: where info came from
+`,
+        personal: `# Docuflow Wiki Schema - Personal
+
+## Domain
+Personal knowledge, learning, and goals.
+
+## Wiki Structure
+
+### Entities (entities/)
+- Topics: areas of interest/expertise
+- Resources: books, courses, websites
+- People: mentors, collaborators
+- Projects: personal projects
+
+### Concepts (concepts/)
+- Learning Goals: what to learn
+- Skills: competencies to develop
+- Insights: key personal learnings
+- Practices: habits and routines
+
+### Syntheses (syntheses/)
+- Reflections: deeper thinking
+- Progress Updates: tracking learning
+- Connections: how ideas relate
+- Action Plans: what to do next
+
+### Timelines (timelines/)
+- Learning Journey: personal evolution
+- Milestones: key achievements
+
+## Cross-Reference Patterns
+- "builds on" - prerequisite knowledge
+- "connects to" - related topics
+- "informs" - influences thinking
+- "inspires" - inspiration source
+- "applies to" - practical application
+
+## Metadata
+Each page should include:
+- created_at: when started learning
+- updated_at: last review
+- relevance: importance (high/medium/low)
+- mastery_level: expertise level (beginner/intermediate/expert)
+- time_invested: hours spent
+`,
+    };
+    return schemas[domain];
+}
+function getPlanningTemplate(domain, projectName) {
+    return `# ${projectName} Wiki Plan
+
+## Goal
+Document and organize knowledge for ${projectName}.
+
+## Initial Sources to Add
+1. [ ] README or main overview
+2. [ ] Key source file 1
+3. [ ] Key source file 2
+
+## Key Entities to Define
+- Entity 1: [description]
+- Entity 2: [description]
+
+## Key Concepts to Extract
+- Concept 1: [description]
+- Concept 2: [description]
+
+## First Questions to Answer
+1. [What do you want to understand first?]
+2. [What relationships are important?]
+
+## Success Criteria
+- [ ] Successfully ingested first 3 sources
+- [ ] Created 10+ wiki pages
+- [ ] Can answer key questions
+- [ ] Wiki is at 80%+ health score
+
+## Next Review Date
+[Date for first maintenance check]
+`;
+}
+async function runInteractive() {
+    console.log("\n🌟 Welcome to Docuflow Wiki Setup!\n");
+    console.log("I'll help you set up a wiki for your project.");
+    console.log("This should take about 2 minutes. You can customize later.\n");
+    // Get domain
+    const domain = await selectDomain();
+    console.log(`✓ Selected: ${domain}`);
+    // Get project info
+    const { name: projectName, description } = await getProjectInfo(domain);
+    console.log(`✓ Project: "${projectName}" - ${description}`);
+    // Confirm setup
+    console.log("\n✨ I'll create a wiki structure for you with recommended schema.");
+    const confirm = await prompt("Ready to proceed? (y/n): ");
+    if (confirm.toLowerCase() !== "y") {
+        console.log("\n👋 Setup cancelled.");
+        return;
+    }
+    // Get schema for domain
+    const domainSchema = getSchemaForDomain(domain);
+    const planTemplate = getPlanningTemplate(domain, projectName);
+    console.log("\n📁 Creating wiki structure...");
+    const docuDir = node_path_1.default.join(process.cwd(), ".docuflow");
+    const wikiDir = node_path_1.default.join(docuDir, "wiki");
+    // Create directories
+    await promises_1.default.mkdir(node_path_1.default.join(wikiDir, "entities"), { recursive: true });
+    await promises_1.default.mkdir(node_path_1.default.join(wikiDir, "concepts"), { recursive: true });
+    await promises_1.default.mkdir(node_path_1.default.join(wikiDir, "syntheses"), { recursive: true });
+    await promises_1.default.mkdir(node_path_1.default.join(wikiDir, "timelines"), { recursive: true });
+    await promises_1.default.mkdir(node_path_1.default.join(docuDir, "sources"), { recursive: true });
+    await promises_1.default.mkdir(node_path_1.default.join(docuDir, "specs"), { recursive: true });
+    console.log("  ✓ Created wiki directories");
+    // Write schema with domain-specific content
+    await promises_1.default.writeFile(node_path_1.default.join(docuDir, "schema.md"), domainSchema, "utf8");
+    console.log("  ✓ Created schema.md with domain-specific structure");
+    // Write index and log
+    const indexContent = `# Wiki Index
+
+Auto-maintained catalog of all wiki pages.
+
+## Generated: ${new Date().toISOString()}
+
+(Index is automatically updated as you ingest sources)
+`;
+    await promises_1.default.writeFile(node_path_1.default.join(docuDir, "index.md"), indexContent, "utf8");
+    console.log("  ✓ Created index.md");
+    const logContent = `# Operation Log
+
+Record of all wiki operations.
+
+## [${new Date().toISOString()}] init | Wiki initialized
+- Domain: ${domain}
+- Project: ${projectName}
+- Description: ${description}
+`;
+    await promises_1.default.writeFile(node_path_1.default.join(docuDir, "log.md"), logContent, "utf8");
+    console.log("  ✓ Created log.md");
+    // Write planning template
+    const planPath = node_path_1.default.join(docuDir, "PLAN.md");
+    await promises_1.default.writeFile(planPath, planTemplate, "utf8");
+    console.log("  ✓ Created PLAN.md (interactive planning guide)");
+    // Generate CLAUDE.md so Claude Code picks up DocuFlow automatically
+    const claudeMdContent = (0, init_1.buildClaudeMd)(process.cwd());
+    const claudeMdPath = node_path_1.default.join(process.cwd(), "CLAUDE.md");
+    if (node_fs_1.default.existsSync(claudeMdPath)) {
+        const existing = await promises_1.default.readFile(claudeMdPath, "utf8");
+        if (existing.includes("DocuFlow")) {
+            const withoutDocuflow = existing.replace(/\n?# DocuFlow[\s\S]*/, "").trimEnd();
+            await promises_1.default.writeFile(claudeMdPath, withoutDocuflow + "\n\n" + claudeMdContent, "utf8");
+        }
+        else {
+            await promises_1.default.appendFile(claudeMdPath, "\n\n" + claudeMdContent, "utf8");
+        }
+    }
+    else {
+        await promises_1.default.writeFile(claudeMdPath, claudeMdContent, "utf8");
+    }
+    console.log("  ✓ Created CLAUDE.md (Claude Code will read DocuFlow tool instructions automatically)");
+    console.log("\n✅ Wiki successfully initialized!\n");
+    // Print summary and next steps
+    console.log("📋 Next Steps:");
+    console.log("  1. Review your schema: .docuflow/schema.md");
+    console.log("  2. Review your plan: .docuflow/PLAN.md");
+    console.log("  3. Add first source: copy to .docuflow/sources/");
+    console.log("  4. Ask Claude: 'Ingest README.md into my wiki'");
+    console.log("  5. Ask Claude: 'What should my wiki contain?'");
+    console.log("\n💡 Tip: Claude Code will automatically read CLAUDE.md for DocuFlow instructions.\n");
+}

package/dist/commands/init.js

@@ -3,6 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildClaudeMd = buildClaudeMd;
 exports.run = run;
 const node_fs_1 = __importDefault(require("node:fs"));
 const promises_1 = __importDefault(require("node:fs/promises"));
@@ -28,6 +29,125 @@ function resolveServerBin() {
         return node_path_1.default.resolve(__dirname, "..", "..", "server", "dist", "index.js");
     }
 }
+async function copyTemplateFile(templateName, destPath) {
+    try {
+        // Try package-installed location first
+        const templatePath = require.resolve(`@doquflow/cli/templates/${templateName}`);
+        const content = await promises_1.default.readFile(templatePath, "utf8");
+        await promises_1.default.writeFile(destPath, content, "utf8");
+    }
+    catch {
+        try {
+            // Fallback: monorepo sibling path (dev environment)
+            const templatePath = node_path_1.default.resolve(__dirname, "..", "..", "templates", templateName);
+            const content = await promises_1.default.readFile(templatePath, "utf8");
+            await promises_1.default.writeFile(destPath, content, "utf8");
+        }
+        catch (err) {
+            // If template not found, create a minimal version
+            console.warn(`  ⚠ Could not find template for ${templateName}, creating minimal version`);
+            if (templateName === "schema.md") {
+                await promises_1.default.writeFile(destPath, "# Docuflow Wiki Schema\n\n## Domain\n[Edit this file to customize your wiki]\n", "utf8");
+            }
+            else if (templateName === "index.md") {
+                await promises_1.default.writeFile(destPath, "# Wiki Index\n\nAuto-maintained catalog of pages.\n", "utf8");
+            }
+            else if (templateName === "log.md") {
+                await promises_1.default.writeFile(destPath, "# Operation Log\n\nRecord of wiki operations.\n", "utf8");
+            }
+        }
+    }
+}
+function buildClaudeMd(projectDir) {
+    return `# DocuFlow — AI Documentation Assistant
+
+DocuFlow is an MCP server that gives you structured access to this codebase and maintains a living wiki.
+It is registered in your Claude Desktop config and available as MCP tools in every session.
+
+## Codebase Scanner Tools
+
+- **read_module** — Analyse a single source file. Returns language, classes, functions, dependencies, DB tables, endpoints, config refs, and raw content (first 8 KB).
+  - Example: \`read_module({ path: "src/UserService.cs" })\`
+- **list_modules** — Walk a directory and extract facts for every non-binary file. Use this to understand the full project in one call.
+  - Example: \`list_modules({ path: "${projectDir}" })\`
+- **write_spec** — Persist a markdown spec to \`.docuflow/specs/<filename>.md\` and update the index.
+  - Example: \`write_spec({ project_path: "${projectDir}", filename: "UserService", content: "# UserService\\n..." })\`
+- **read_specs** — Read previously written specs, optionally filtered by name.
+  - Example: \`read_specs({ project_path: "${projectDir}" })\`
+
+## Wiki Pipeline Tools
+
+- **ingest_source** — Ingest a markdown file from \`.docuflow/sources/\` and generate wiki pages (entities, concepts).
+- **update_index** — Rebuild \`.docuflow/index.md\` from all wiki pages.
+- **list_wiki** — List all wiki pages, optionally filtered by category (entity/concept/timeline/synthesis).
+- **wiki_search** — BM25 search across all wiki pages. Returns ranked results with previews.
+- **query_wiki** — One-stop Q&A: searches wiki, synthesises an answer, returns source citations.
+- **synthesize_answer** — Generate a markdown synthesis from a list of specific wiki page IDs.
+- **save_answer_as_page** — Persist a synthesised answer back into the wiki (knowledge compounding).
+
+## Health & Guidance Tools
+
+- **lint_wiki** — Health check: orphan pages, broken refs, stale content, metadata gaps. Returns a 0–100 health score.
+- **get_schema_guidance** — Analyse what wiki pages should exist based on the schema and current state.
+- **preview_generation** — Preview what a tool will do before running it.
+
+## Common Workflows
+
+### First time — understand the codebase
+\`\`\`
+list_modules({ path: "${projectDir}" })
+→ read the language breakdown and dependency map
+→ write_spec each important module
+\`\`\`
+
+### Ongoing — answer a question
+\`\`\`
+query_wiki({ project_path: "${projectDir}", question: "How does authentication work?" })
+→ save_answer_as_page if the answer is worth keeping
+\`\`\`
+
+### Maintenance — check wiki health
+\`\`\`
+lint_wiki({ project_path: "${projectDir}" })
+→ fix orphans and broken refs
+\`\`\`
+
+## Storage Layout
+
+\`\`\`
+.docuflow/
+├── specs/           Legacy spec files written by write_spec
+├── wiki/            LLM-generated wiki pages
+│   ├── entities/    Named things (services, APIs, databases)
+│   ├── concepts/    Design patterns, principles, integrations
+│   ├── timelines/   Chronological pages
+│   └── syntheses/   Cross-cutting synthesis pages
+├── sources/         Raw input files for ingest_source
+├── schema.md        Wiki configuration (edit to customise)
+├── index.md         Auto-maintained catalog
+└── log.md           Operation log
+\`\`\`
+`;
+}
+async function writeClaudeMd(projectDir) {
+    const claudeMdPath = node_path_1.default.join(projectDir, "CLAUDE.md");
+    const newSection = buildClaudeMd(projectDir);
+    if (node_fs_1.default.existsSync(claudeMdPath)) {
+        const existing = await promises_1.default.readFile(claudeMdPath, "utf8");
+        if (existing.includes("DocuFlow")) {
+            // Already has DocuFlow section — replace it
+            const withoutDocuflow = existing.replace(/\n?# DocuFlow[\s\S]*/, "").trimEnd();
+            await promises_1.default.writeFile(claudeMdPath, withoutDocuflow + "\n\n" + newSection, "utf8");
+        }
+        else {
+            // Append to existing CLAUDE.md
+            await promises_1.default.appendFile(claudeMdPath, "\n\n" + newSection, "utf8");
+        }
+    }
+    else {
+        await promises_1.default.writeFile(claudeMdPath, newSection, "utf8");
+    }
+}
 async function run() {
     const configPath = getClaudeDesktopConfigPath();
     const serverBin = resolveServerBin();
@@ -46,9 +166,28 @@ async function run() {
     config.mcpServers.docuflow = { command: nodeBin, args: [serverBin] };
     await promises_1.default.mkdir(node_path_1.default.dirname(configPath), { recursive: true });
     await promises_1.default.writeFile(configPath, JSON.stringify(config, null, 2) + "\n", "utf8");
-    // Create .docuflow/specs/ in cwd
-    const specsDir = node_path_1.default.join(process.cwd(), ".docuflow", "specs");
+    // Create .docuflow/ directory structure
+    const projectDir = process.cwd();
+    const docuflowDir = node_path_1.default.join(projectDir, ".docuflow");
+    const specsDir = node_path_1.default.join(docuflowDir, "specs");
+    const wikiDir = node_path_1.default.join(docuflowDir, "wiki");
+    const sourcesDir = node_path_1.default.join(docuflowDir, "sources");
+    const entitiesDir = node_path_1.default.join(wikiDir, "entities");
+    const conceptsDir = node_path_1.default.join(wikiDir, "concepts");
+    const timelinesDir = node_path_1.default.join(wikiDir, "timelines");
+    const synthesesDir = node_path_1.default.join(wikiDir, "syntheses");
     await promises_1.default.mkdir(specsDir, { recursive: true });
+    await promises_1.default.mkdir(entitiesDir, { recursive: true });
+    await promises_1.default.mkdir(conceptsDir, { recursive: true });
+    await promises_1.default.mkdir(timelinesDir, { recursive: true });
+    await promises_1.default.mkdir(synthesesDir, { recursive: true });
+    await promises_1.default.mkdir(sourcesDir, { recursive: true });
+    // Copy or create template files
+    await copyTemplateFile("schema.md", node_path_1.default.join(docuflowDir, "schema.md"));
+    await copyTemplateFile("index.md", node_path_1.default.join(docuflowDir, "index.md"));
+    await copyTemplateFile("log.md", node_path_1.default.join(docuflowDir, "log.md"));
+    // Generate CLAUDE.md so Claude Code picks up DocuFlow automatically
+    await writeClaudeMd(projectDir);
     // Add .docuflow/ to .gitignore if present and not already listed
     const gitignorePath = node_path_1.default.join(process.cwd(), ".gitignore");
     if (node_fs_1.default.existsSync(gitignorePath)) {
@@ -57,11 +196,32 @@ async function run() {
             await promises_1.default.appendFile(gitignorePath, "\n# Docuflow\n.docuflow/\n");
         }
     }
-    console.log("Docuflow initialised successfully.");
+    console.log("✓ Docuflow initialised successfully.");
+    console.log("");
+    console.log("📁 Structure created:");
+    console.log(`  ${docuflowDir}/`);
+    console.log(`  ├── specs/              (for legacy specs)`);
+    console.log(`  ├── wiki/               (LLM-generated pages)`);
+    console.log(`  │   ├── entities/`);
+    console.log(`  │   ├── concepts/`);
+    console.log(`  │   ├── timelines/`);
+    console.log(`  │   └── syntheses/`);
+    console.log(`  ├── sources/            (immutable raw files)`);
+    console.log(`  ├── schema.md           (wiki configuration)`);
+    console.log(`  ├── index.md            (auto-maintained catalog)`);
+    console.log(`  └── log.md              (operation log)`);
+    console.log("");
+    console.log("📝 CLAUDE.md:");
+    console.log(`  Generated at: ${node_path_1.default.join(projectDir, "CLAUDE.md")}`);
+    console.log(`  Claude Code will automatically read DocuFlow tool instructions.`);
     console.log("");
+    console.log("🔧 MCP Configuration:");
     console.log(`  MCP key:     mcpServers.docuflow`);
     console.log(`  Config file: ${configPath}`);
-    console.log(`  Specs dir:   ${specsDir}`);
     console.log("");
-    console.log("Restart Claude Desktop to activate.");
+    console.log("📖 Next steps:");
+    console.log("  1. Edit .docuflow/schema.md to customize your wiki");
+    console.log("  2. Add source files to .docuflow/sources/");
+    console.log("  3. Use LLM Wiki tools to ingest, query, and maintain wiki");
+    console.log("  4. Restart Claude Desktop to activate");
 }

package/dist/commands/status.js

@@ -7,6 +7,7 @@ exports.run = run;
 const promises_1 = __importDefault(require("node:fs/promises"));
 const node_path_1 = __importDefault(require("node:path"));
 const node_os_1 = __importDefault(require("node:os"));
+const node_fs_1 = __importDefault(require("node:fs"));
 function getClaudeDesktopConfigPath() {
     const platform = process.platform;
     if (platform === "darwin") {
@@ -17,8 +18,33 @@ function getClaudeDesktopConfigPath() {
     }
     return node_path_1.default.join(node_os_1.default.homedir(), ".config", "Claude", "claude_desktop_config.json");
 }
+async function readLastIngestDate(docuDir) {
+    try {
+        const log = await promises_1.default.readFile(node_path_1.default.join(docuDir, "log.md"), "utf8");
+        const match = log.match(/\[(\d{4}-\d{2}-\d{2}[^\]]*)\]\s+ingest/);
+        return match ? match[1] : "never";
+    }
+    catch {
+        return "never";
+    }
+}
+async function countWikiPages(docuDir) {
+    const counts = { entities: 0, concepts: 0, timelines: 0, syntheses: 0 };
+    for (const cat of Object.keys(counts)) {
+        try {
+            const files = await promises_1.default.readdir(node_path_1.default.join(docuDir, "wiki", cat));
+            counts[cat] = files.filter((f) => f.endsWith(".md")).length;
+        }
+        catch {
+            // Directory may not exist
+        }
+    }
+    return counts;
+}
 async function run() {
     const configPath = getClaudeDesktopConfigPath();
+    const projectDir = process.cwd();
+    const docuDir = node_path_1.default.join(projectDir, ".docuflow");
     // Check MCP registration
     let registered = false;
     try {
@@ -31,21 +57,73 @@ async function run() {
     }
     // Count spec files
     let specCount = 0;
-    const specsDir = node_path_1.default.join(process.cwd(), ".docuflow", "specs");
     try {
-        const entries = await promises_1.default.readdir(specsDir);
-        specCount = entries.filter(e => e.endsWith(".md")).length;
+        const entries = await promises_1.default.readdir(node_path_1.default.join(docuDir, "specs"));
+        specCount = entries.filter((e) => e.endsWith(".md")).length;
     }
     catch {
         // .docuflow/specs doesn't exist
     }
-    console.log("Docuflow status");
-    console.log("───────────────────────────────");
-    console.log(`  MCP registered: ${registered ? "yes" : "no"}`);
-    console.log(`  Specs written:  ${specCount}`);
-    console.log(`  Config file:    ${configPath}`);
+    // Count sources
+    let sourceCount = 0;
+    try {
+        const entries = await promises_1.default.readdir(node_path_1.default.join(docuDir, "sources"));
+        sourceCount = entries.filter((e) => e.endsWith(".md") || e.endsWith(".txt")).length;
+    }
+    catch {
+        // .docuflow/sources doesn't exist
+    }
+    // Check for CLAUDE.md
+    const claudeMdExists = node_fs_1.default.existsSync(node_path_1.default.join(projectDir, "CLAUDE.md"));
+    // Count wiki pages per category
+    const wikiCounts = await countWikiPages(docuDir);
+    const totalWikiPages = Object.values(wikiCounts).reduce((a, b) => a + b, 0);
+    // Last ingest date
+    const lastIngest = await readLastIngestDate(docuDir);
+    // Get CLI version from package.json
+    let version = "unknown";
+    try {
+        const pkgPath = require.resolve("@doquflow/cli/package.json");
+        const pkg = JSON.parse(await promises_1.default.readFile(pkgPath, "utf8"));
+        version = pkg.version;
+    }
+    catch {
+        try {
+            const pkgPath = node_path_1.default.resolve(__dirname, "..", "..", "package.json");
+            const pkg = JSON.parse(await promises_1.default.readFile(pkgPath, "utf8"));
+            version = pkg.version;
+        }
+        catch {
+            // Can't resolve version
+        }
+    }
+    console.log("\nDocuflow status");
+    console.log("───────────────────────────────────────────");
+    console.log(`  Version:          ${version}`);
+    console.log(`  MCP registered:   ${registered ? "✓ yes" : "✗ no"}`);
+    console.log(`  CLAUDE.md:        ${claudeMdExists ? "✓ present" : "✗ missing"}`);
+    console.log(`  Config file:      ${configPath}`);
+    console.log("");
+    console.log("  Specs written:    " + specCount);
+    console.log("  Sources:          " + sourceCount);
+    console.log("  Last ingest:      " + lastIngest);
+    console.log("");
+    console.log("  Wiki pages:       " + totalWikiPages + " total");
+    if (totalWikiPages > 0) {
+        console.log(`    entities:       ${wikiCounts.entities}`);
+        console.log(`    concepts:       ${wikiCounts.concepts}`);
+        console.log(`    syntheses:      ${wikiCounts.syntheses}`);
+        console.log(`    timelines:      ${wikiCounts.timelines}`);
+    }
+    console.log("───────────────────────────────────────────");
     if (!registered) {
-        console.log("");
-        console.log('  Run "docuflow init" to register.');
+        console.log('\n  ⚠  Run "docuflow init" to register MCP server.');
+    }
+    if (!claudeMdExists) {
+        console.log('\n  ⚠  Run "docuflow init" to generate CLAUDE.md.');
+    }
+    if (totalWikiPages === 0 && sourceCount === 0) {
+        console.log('\n  💡 Run "docuflow suggest" to see what to document first.');
     }
+    console.log();
 }

package/dist/commands/suggest.js

@@ -0,0 +1,130 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.run = run;
+const promises_1 = __importDefault(require("node:fs/promises"));
+const node_path_1 = __importDefault(require("node:path"));
+const node_fs_1 = __importDefault(require("node:fs"));
+const DOMAIN_SUGGESTIONS = {
+    "Code/Architecture": [
+        { priority: 1, type: "wiki_page", title: "System Architecture Overview", reason: "High-level view of how all components fit together", prompt: "Ingest the README or architecture doc, then ask: 'Create a System Architecture Overview page in the wiki'" },
+        { priority: 2, type: "wiki_page", title: "Core Architectural Patterns", reason: "Design patterns used throughout the codebase", prompt: "Ask Claude: 'Scan the codebase with list_modules and identify the core architectural patterns'" },
+        { priority: 3, type: "wiki_page", title: "Module Dependencies", reason: "Which modules depend on which — risky to change without knowing", prompt: "Ask Claude: 'Use list_modules to build a module dependency map and write it as a wiki page'" },
+        { priority: 4, type: "wiki_page", title: "Database Schema Overview", reason: "Tables, relationships, and ownership by module", prompt: "Ask Claude: 'Scan the project for DB tables using list_modules and create a Database Schema wiki page'" },
+        { priority: 5, type: "starter_question", title: "What modules are most connected?", reason: "Identifies the highest-risk code to change", prompt: "Ask Claude: 'Use list_modules on this project and tell me which files have the most dependencies'" },
+    ],
+    Research: [
+        { priority: 1, type: "wiki_page", title: "Research Domain Overview", reason: "Big picture of the research area", prompt: "Ingest your main survey paper, then ask: 'Create a Research Domain Overview page'" },
+        { priority: 2, type: "wiki_page", title: "Key Findings & Synthesis", reason: "Major discoveries and insights", prompt: "Ask Claude: 'After ingesting my sources, synthesize the key findings into a wiki page'" },
+        { priority: 3, type: "wiki_page", title: "Areas of Contradiction", reason: "Where researchers disagree — critical to track", prompt: "Ask Claude: 'Run lint_wiki and identify any contradictions, then create an Areas of Contradiction page'" },
+        { priority: 4, type: "wiki_page", title: "Open Research Questions", reason: "What's still unknown in this domain", prompt: "Ask Claude: 'Based on ingested sources, what questions remain unanswered?'" },
+        { priority: 5, type: "starter_question", title: "What are the most cited entities?", reason: "Shows which concepts are most important", prompt: "Ask Claude: 'Which entities appear most often across all ingested sources?'" },
+    ],
+    Business: [
+        { priority: 1, type: "wiki_page", title: "Market Overview", reason: "Big picture of the market and competitive landscape", prompt: "Ingest market research docs, then ask: 'Create a Market Overview wiki page'" },
+        { priority: 2, type: "wiki_page", title: "Competitive Analysis", reason: "How competitors differ — essential strategic context", prompt: "Ask Claude: 'After ingesting competitor info, create a Competitive Analysis synthesis page'" },
+        { priority: 3, type: "wiki_page", title: "Market Opportunities", reason: "Gaps and growth areas to track", prompt: "Ask Claude: 'Identify market opportunities from ingested sources and create a wiki page'" },
+        { priority: 4, type: "wiki_page", title: "Key Players", reason: "Entities (companies, people) to track over time", prompt: "Ask Claude: 'Create an entity page for each key competitor found in sources'" },
+        { priority: 5, type: "starter_question", title: "Who are the key players in this market?", reason: "First question to anchor the wiki", prompt: "Ask Claude: 'List the key companies and people from ingested market data'" },
+    ],
+    Personal: [
+        { priority: 1, type: "wiki_page", title: "Learning Goals", reason: "Anchors everything else in the wiki", prompt: "Ask Claude: 'Create a Learning Goals page from my notes in .docuflow/sources/'" },
+        { priority: 2, type: "wiki_page", title: "Key Personal Insights", reason: "Preserve insights before they fade", prompt: "Ask Claude: 'Ingest my notes and create a Key Insights synthesis page'" },
+        { priority: 3, type: "wiki_page", title: "Key Resources", reason: "Books, courses, links to revisit", prompt: "Ask Claude: 'Extract and create an entity page for each key resource mentioned in my notes'" },
+        { priority: 4, type: "wiki_page", title: "Action Items & Next Steps", reason: "Turns knowledge into action", prompt: "Ask Claude: 'What action items can you find across my wiki pages? Create a synthesis page'" },
+        { priority: 5, type: "starter_question", title: "What do I already know about this topic?", reason: "Baseline before adding more sources", prompt: "Ask Claude: 'Query the wiki for what I know about [your topic]'" },
+    ],
+    General: [
+        { priority: 1, type: "action", title: "Add your first source file", reason: "Nothing can be ingested until you put a file in .docuflow/sources/", prompt: "Copy your README, main doc, or any markdown file into .docuflow/sources/" },
+        { priority: 2, type: "wiki_page", title: "Overview / Summary page", reason: "A starting page that links to everything else", prompt: "Ask Claude: 'Ingest my first source and create an overview synthesis page'" },
+        { priority: 3, type: "starter_question", title: "What are the key entities in this domain?", reason: "Gets the wiki started with real content", prompt: "Ask Claude: 'After ingesting my first source, what are the key entities?'" },
+        { priority: 4, type: "wiki_page", title: "Key Concepts", reason: "Important ideas worth preserving", prompt: "Ask Claude: 'Create concept pages for the top 5 ideas from ingested sources'" },
+        { priority: 5, type: "action", title: "Run get_schema_guidance", reason: "DocuFlow will tell you what's missing based on your domain", prompt: "Ask Claude: 'Run get_schema_guidance on my project and show what pages are recommended'" },
+    ],
+};
+function detectDomain(schemaContent) {
+    if (/Architecture|Code|codebase|microservice|API/i.test(schemaContent))
+        return "Code/Architecture";
+    if (/Research|paper|findings|literature/i.test(schemaContent))
+        return "Research";
+    if (/Business|market|competitor|revenue/i.test(schemaContent))
+        return "Business";
+    if (/Personal|learning|goal|habit/i.test(schemaContent))
+        return "Personal";
+    return "General";
+}
+async function countWikiPages(docuDir) {
+    const counts = { entities: 0, concepts: 0, timelines: 0, syntheses: 0 };
+    for (const cat of Object.keys(counts)) {
+        try {
+            const files = await promises_1.default.readdir(node_path_1.default.join(docuDir, "wiki", cat));
+            counts[cat] = files.filter((f) => f.endsWith(".md")).length;
+        }
+        catch {
+            // Directory may not exist
+        }
+    }
+    return counts;
+}
+async function countSources(docuDir) {
+    try {
+        const files = await promises_1.default.readdir(node_path_1.default.join(docuDir, "sources"));
+        return files.filter((f) => f.endsWith(".md") || f.endsWith(".txt")).length;
+    }
+    catch {
+        return 0;
+    }
+}
+async function run() {
+    const projectDir = process.cwd();
+    const docuDir = node_path_1.default.join(projectDir, ".docuflow");
+    if (!node_fs_1.default.existsSync(docuDir)) {
+        console.log("⚠  DocuFlow not initialised in this directory.");
+        console.log('   Run "docuflow init" first.\n');
+        return;
+    }
+    // Detect domain from schema
+    let domain = "General";
+    try {
+        const schema = await promises_1.default.readFile(node_path_1.default.join(docuDir, "schema.md"), "utf8");
+        domain = detectDomain(schema);
+    }
+    catch {
+        // No schema yet — fall back to General
+    }
+    const [pageCounts, sourceCount] = await Promise.all([
+        countWikiPages(docuDir),
+        countSources(docuDir),
+    ]);
+    const totalPages = Object.values(pageCounts).reduce((a, b) => a + b, 0);
+    console.log(`\n💡 DocuFlow Suggestions — ${domain} domain\n`);
+    console.log(`   Current wiki: ${totalPages} pages | ${sourceCount} source(s) ingested\n`);
+    if (totalPages === 0 && sourceCount === 0) {
+        console.log("🌱 Your wiki is empty. Here's where to start:\n");
+    }
+    else if (totalPages < 10) {
+        console.log("📚 Wiki is growing. Recommended next pages:\n");
+    }
+    else {
+        console.log("✅ Good coverage. Here's what could be stronger:\n");
+    }
+    const suggestions = DOMAIN_SUGGESTIONS[domain] ?? DOMAIN_SUGGESTIONS.General;
+    for (const s of suggestions) {
+        const icon = s.type === "action" ? "▶" : s.type === "starter_question" ? "❓" : "📄";
+        console.log(`  ${s.priority}. ${icon} ${s.title}`);
+        console.log(`     ${s.reason}`);
+        if (s.prompt) {
+            console.log(`     → ${s.prompt}`);
+        }
+        console.log();
+    }
+    console.log("─────────────────────────────────────────────────────");
+    console.log("Quick start prompts for Claude:\n");
+    console.log(`  • "Scan the project at ${projectDir} with list_modules"`);
+    console.log(`  • "Show me get_schema_guidance for ${projectDir}"`);
+    console.log(`  • "What wiki pages exist? Run list_wiki on ${projectDir}"`);
+    console.log(`  • "What should I document first in this project?"`);
+    console.log();
+}

package/dist/index.js

@@ -33,16 +33,26 @@ var __importStar = (this && this.__importStar) || (function () {
         return result;
     };
 })();
-const [, , cmd] = process.argv;
+const [, , cmd, flag] = process.argv;
 if (cmd === 'init') {
-    Promise.resolve().then(() => __importStar(require('./commands/init'))).then(m => m.run());
+    if (flag === '--interactive' || flag === '-i') {
+        Promise.resolve().then(() => __importStar(require('./commands/init-interactive'))).then(m => m.runInteractive());
+    }
+    else {
+        Promise.resolve().then(() => __importStar(require('./commands/init'))).then(m => m.run());
+    }
 }
 else if (cmd === 'status') {
     Promise.resolve().then(() => __importStar(require('./commands/status'))).then(m => m.run());
 }
+else if (cmd === 'suggest') {
+    Promise.resolve().then(() => __importStar(require('./commands/suggest'))).then(m => m.run());
+}
 else {
-    console.log('Usage: npx @doquflow/cli <init|status>');
+    console.log('Usage: npx @doquflow/cli <command>');
     console.log('');
-    console.log('  init    Register Docuflow MCP server in Claude Desktop config');
-    console.log('  status  Show spec count and MCP registration status');
+    console.log('  init              Register Docuflow MCP and generate CLAUDE.md');
+    console.log('  init --interactive  Interactive setup wizard (choose domain, project name)');
+    console.log('  status            Show wiki health, page counts, and MCP status');
+    console.log('  suggest           Show what to document first (domain-specific guidance)');
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@doquflow/cli",
-  "version": "0.2.0",
+  "version": "0.4.0",
   "description": "CLI for setting up Docuflow in your project",
   "author": "Docuflow <hello@doquflows.dev>",
   "license": "MIT",
@@ -30,7 +30,7 @@
     "build": "tsc"
   },
   "dependencies": {
-    "@doquflow/server": "0.2.0"
+    "@doquflow/server": "0.4.0"
   },
   "devDependencies": {
     "@types/node": "^22.0.0",