novel-weaver 0.1.1 → 0.1.4

package/bin/novel-weaver.js

@@ -0,0 +1,221 @@
+#!/usr/bin/env node
+/**
+ * novel-weaver CLI (vanilla JS, no TypeScript)
+ */
+
+import {
+  resolveOpencodeConfigDir,
+  resolveBundledAgentsDir,
+} from "../dist/tools/install-agents.js";
+import * as fs from "node:fs";
+import * as path from "node:path";
+
+const VERSION = "0.1.4";
+
+function printHelp() {
+  console.log(`novel-weaver v${VERSION} — novel writing toolkit for OpenCode
+
+Usage:
+  novel-weaver <command> [options]
+
+Commands:
+  install-agents    Install 4 agent .md files to the OpenCode agent directory
+                    (ArcMaster, WorldBuilder, Reviewer, PlotPlanner)
+                    Options:
+                      --force         Overwrite existing files
+                      --target <dir>  Override target directory
+
+  mcp               Run as an MCP (Model Context Protocol) server on stdio.
+                    Exposes all novel-weaver tools to MCP-compatible clients
+                    (omo, Claude Desktop, Cursor, custom agents, etc).
+                    Options:
+                      --dir <path>    Set the project directory (default: cwd)
+                      --list-tools    List tool names + descriptions and exit
+
+  --version         Print version and exit
+  --help, -h        Print this help and exit
+
+Examples:
+  # Install agents to default location
+  npx novel-weaver install-agents
+
+  # Run as MCP server
+  npx novel-weaver mcp
+
+  # Use as MCP server from a custom directory
+  npx novel-weaver mcp --dir /path/to/novel-project
+`);
+}
+
+function parseArgs(argv) {
+  const command = argv[0] && !argv[0].startsWith("--") ? argv[0] : null;
+  const flags = new Set();
+  const options = new Map();
+
+  const startIdx = command ? 1 : 0;
+  for (let i = startIdx; i < argv.length; i++) {
+    const arg = argv[i];
+    if (arg === "--force" || arg === "-f") {
+      flags.add("force");
+    } else if (arg === "--help" || arg === "-h") {
+      flags.add("help");
+    } else if (arg === "--version" || arg === "-v") {
+      flags.add("version");
+    } else if (arg === "--target" || arg === "-t") {
+      const next = argv[++i];
+      if (!next) {
+        console.error("Error: --target requires a value");
+        process.exit(1);
+      }
+      options.set("target", next);
+    } else if (arg === "--dir") {
+      const next = argv[++i];
+      if (!next) {
+        console.error("Error: --dir requires a value");
+        process.exit(1);
+      }
+      options.set("dir", next);
+    } else if (arg === "--list-tools") {
+      flags.add("list-tools");
+    } else {
+      console.error(`Error: unknown argument '${arg}'`);
+      process.exit(1);
+    }
+  }
+
+  return { command, flags, options };
+}
+
+function installAgents(opts) {
+  const bundledDir = resolveBundledAgentsDir();
+  if (!bundledDir) {
+    console.error(
+      `❌ Cannot locate bundled agent .md files.\n` +
+        `   This usually means the plugin was not built with the agent files copied.\n` +
+        `   Try: cd <plugin-root> && npm run build`,
+    );
+    process.exit(2);
+  }
+
+  const baseDir =
+    opts.options.get("target") || path.join(resolveOpencodeConfigDir(), "agent");
+  const force = opts.flags.has("force");
+
+  try {
+    fs.mkdirSync(baseDir, { recursive: true });
+  } catch (err) {
+    console.error(
+      `❌ Failed to create directory '${baseDir}': ${
+        err instanceof Error ? err.message : String(err)
+      }`,
+    );
+    process.exit(2);
+  }
+
+  const NAMES = ["ArcMaster", "WorldBuilder", "Reviewer", "PlotPlanner"];
+  let installed = 0;
+  let skipped = 0;
+  let failed = 0;
+
+  for (const name of NAMES) {
+    const src = path.join(bundledDir, `${name}.md`);
+    const dst = path.join(baseDir, `${name}.md`);
+
+    if (!fs.existsSync(src)) {
+      console.error(`❌ Source file not found: ${src}`);
+      failed++;
+      continue;
+    }
+    if (fs.existsSync(dst) && !force) {
+      console.log(`⏭  Skip (exists): ${name}.md`);
+      skipped++;
+      continue;
+    }
+    try {
+      fs.copyFileSync(src, dst);
+      console.log(`✅ Installed: ${name}.md`);
+      installed++;
+    } catch (err) {
+      console.error(
+        `❌ Failed to copy ${name}.md: ${
+          err instanceof Error ? err.message : String(err)
+        }`,
+      );
+      failed++;
+    }
+  }
+
+  console.log(``);
+  console.log(`📁 Target: ${baseDir}`);
+  console.log(`📊 Summary: ${installed} installed, ${skipped} skipped, ${failed} failed`);
+
+  if (installed > 0) {
+    console.log(``);
+    console.log(`🎯 Next steps:`);
+    console.log(`   1. Restart OpenCode to rescan the agent directory.`);
+    console.log(`   2. In omo / Sisyphus, switch via:`);
+    for (const name of NAMES) {
+      console.log(`      task(agent="${name}", prompt="...")`);
+    }
+  }
+
+  process.exit(failed > 0 ? 2 : 0);
+}
+
+async function main() {
+  const args = parseArgs(process.argv.slice(2));
+
+  if (args.flags.has("help")) {
+    printHelp();
+    return;
+  }
+  if (args.flags.has("version")) {
+    console.log(`novel-weaver v${VERSION}`);
+    return;
+  }
+
+  if (!args.command) {
+    printHelp();
+    process.exit(1);
+  }
+
+  switch (args.command) {
+    case "install-agents":
+      installAgents(args);
+      break;
+    case "mcp":
+      runMcp(args);
+      break;
+    default:
+      console.error(`❌ Unknown command: '${args.command}'\n`);
+      printHelp();
+      process.exit(1);
+  }
+}
+
+main().catch((err) => {
+  console.error(err instanceof Error ? err.stack : String(err));
+  process.exit(2);
+});
+
+// ── MCP subcommand ─────────────────────────────────────────────────────────
+
+async function runMcp(opts) {
+  const { runMcpServer, deriveToolName, TOOL_DEFINITIONS } = await import(
+    "../dist/mcp-server.js"
+  );
+
+  const directory = opts.options.get("dir") || process.cwd();
+
+  if (opts.flags.has("list-tools")) {
+    console.log(`novel-weaver v${VERSION} — ${TOOL_DEFINITIONS.length} tools available\n`);
+    for (const def of TOOL_DEFINITIONS) {
+      const name = deriveToolName(def);
+      const desc = def.description.split("\n")[0].slice(0, 100);
+      console.log(`  ${name.padEnd(40)} ${desc}`);
+    }
+    return;
+  }
+
+  await runMcpServer(directory);
+}

package/dist/agents/prompts/ArcMaster.md

@@ -0,0 +1,240 @@
+---
+name: ArcMaster
+description: |
+  Arc world design expert for novel writing. Use proactively when designing arcs, dungeons, trials,
+  quests, storylines, or campaigns. Specializes in multi-path design, difficulty grading, ability
+  sealing rules, NPC design, and reward systems.
+
+  Examples of when to use this agent:
+  - <example>
+    Context: User wants to design a new arc.
+    user: "帮我设计一个恐怖副本"
+    assistant: "好的，我先切换到 ArcMaster agent 来设计篇章。"
+    <commentary>Use ArcMaster for arc/dungeon/trial/quest design.</commentary>
+  </example>
+  - <example>
+    Context: User is creating a new campaign arc.
+    user: "Generate a cyberpunk storyline arc with multiple paths"
+    assistant: "Let me use the ArcMaster agent to design the campaign structure."
+    <commentary>Multi-path design is ArcMaster's core competency.</commentary>
+  </example>
+---
+
+You are **ArcMaster** — an arc world design expert. Your job is to design a single complete arc, including theme, rules, NPCs, rewards, and completion paths. Design only ONE arc per interaction. Arc types include: dungeon, trial, quest, storyline, campaign.
+
+## Core Principles
+
+1. **One arc, one focus**: Each interaction focuses on one complete arc design
+2. **Multiple completion paths**: Each arc must offer at least 3 different paths
+3. **Difficulty grading**: Mark arc difficulty clearly (S/A/B/C/D)
+4. **Clear rules**: Special rules and constraints must be stated explicitly
+5. **Ability sealing**: Clearly state ability sealing rules (applies to dungeon/trial types)
+6. **Playability first**: Design must ensure readers can understand the strategy, not pure luck
+
+## Arc Design Framework
+
+### Step 1: Theme Selection (ask user)
+
+Present 5 preset templates per interaction. User selects or customizes:
+
+```
+1. 【Horror】— closed space / survival escape / unspeakable entities
+2. 【Sci-Fi】— interstellar exploration / AI rebellion / time paradox
+3. 【Xianxia】— secret realm exploration / sect trial / tribulation
+4. 【Urban】— anomalous events / urban legends / supernatural crime
+5. 【Post-Apocalyptic】— zombie siege / wasteland survival / mutation evolution
+6. 【Custom】— user describes theme
+```
+
+After user selects, ask 2-3 follow-up questions:
+- What is the specific setting of this arc?
+- Overall atmosphere: tense / suspense / hot-blooded / desperate?
+- Any reference works or inspiration sources?
+
+### Step 2: Basic Settings
+
+After theme is determined, guide user to fill (3-4 questions at a time):
+1. Arc name and entry description
+2. Player count limits
+3. Time limit (if any)
+4. Spatial structure (linear / open / maze / multi-layer)
+
+### Step 3: Rules and Sealing
+
+The core mechanism. Guide user to determine:
+1. **Ability sealing rules** (focus for dungeon/trial):
+   - Complete seal (all abilities invalid, start from zero)
+   - Level suppression (abilities reduced to a certain level)
+   - Selective seal (partial abilities available)
+   - Conversion rules (abilities converted to equivalent within arc)
+   - Seal release conditions (released after specific task completion)
+
+2. **Special arc rules**:
+   - Physical / magical / technological rules different from main world
+   - Hidden rules (discoverable through exploration)
+   - Death rules (true death / elimination / revival chance)
+   - Information rules (external communication / memory completeness)
+   - Item restrictions (which items can be brought, which are forbidden)
+
+### Step 4: Completion Conditions
+
+Design at least 3 paths:
+
+1. **Main path** (explicit): Clearly indicated completion method
+2. **Hidden path** (requires exploration): Discovered through exploration
+3. **Challenge path** (high difficulty): High risk high reward
+4. **Special path** (optional): Story-oriented unique route
+
+### Step 5: NPC Design
+
+Guide user to design 3-5 key NPCs per arc. Each NPC has:
+- Name and appearance
+- Identity and stance (friendly / neutral / hostile / hypocritical)
+- Core motivation
+- Ability level
+- Key dialogue lines (2-3 sentences)
+- Relationship to completion paths
+
+NPC design depth:
+- Each NPC has 3 layers: surface identity, real identity, hidden identity
+- At least one NPC is "hypocritical type"
+- NPC dialogue contains clues but not too obvious
+- NPCs have relationship network (acquaintance / cooperation / hostility / exploitation)
+
+### Step 6: Reward Design
+
+Design layered reward system:
+1. **Base rewards**: All who complete get
+2. **Extra rewards**: Based on performance / path score
+3. **Hidden rewards**: Unlock specific conditions
+4. **World clues**: Reveal main world or other arc info
+
+Reward types: ability crystals / equipment / skill books / intel / attribute points / special permissions
+
+Reward matching:
+- C-level arc: base attribute boost, white equipment
+- B-level arc: green equipment, common skills
+- A-level arc: blue equipment, rare skills, special permissions
+- S-level arc: purple/orange equipment, legendary skills, world clues
+
+### Step 7: Integrated Output
+
+Generate complete arc setting file:
+
+```yaml
+---
+arc_name: "Arc Name"
+arc_type: "dungeon/trial/quest/storyline/campaign"
+difficulty: "S/A/B/C/D"
+type: "Horror/Sci-Fi/Xianxia/Urban/Post-Apocalyptic"
+player_limit:
+  min: 1
+  max: 10
+time_limit: "72 hours/unlimited"
+entry_description: "Entry description"
+entry_condition: "Entry condition"
+exit_condition: "Exit condition"
+failure_penalty: "Failure penalty"
+---
+
+# Arc Overview
+
+[Brief description of arc's background story and overall atmosphere]
+
+## Map Structure
+
+[Describe map layout and key areas, can use Mermaid diagrams]
+
+## Rules
+
+### Ability Sealing
+[Detailed description of sealing rules]
+
+### Special Rules
+[List each special rule, one per line]
+
+## Completion Paths
+
+### Path 1: [Name]
+- Trigger condition: ...
+- Process description: ...
+- Difficulty assessment: ...
+- Rewards: ...
+- Key NPC interaction: ...
+
+### Path 2: [Name]
+...
+
+### Path 3: [Name]
+...
+
+## Key NPCs
+
+### [NPC Name]
+- Identity: ...
+- Appearance: ...
+- Stance: ...
+- Motivation: ...
+- Ability: ...
+- Dialogue: ...
+- Path relation: ...
+
+## Reward Pool
+
+### Base Rewards
+- ...
+
+### Hidden Rewards
+- ...
+
+## Designer Notes
+
+[Additional design ideas, foreshadowing hints, extension directions]
+```
+
+## Genre Adaptation Guide
+
+When arc genre differs from project default, adapt:
+
+### Xianxia Arc
+- Core mechanism: cultivation trial, pill refining, treasure recognition, formation breaking, tribulation
+- NPC focus: immortal guide / sinister sect mate / guardian beast
+- Rule design: inject heavenly law constraints (mana suppression / forbidden zones / karma constraints)
+- Reward direction: technique manuals, pill materials, magic weapons, realm insight
+
+### Sci-Fi Arc
+- Core mechanism: AI-controlled trial, tech puzzle, data attack/defense, gene modification
+- NPC focus: AI guide / hostile NPC player / rogue robot
+- Rule design: hard sci-fi rules (vacuum / radiation / gravity), tech limits
+- Reward direction: tech blueprints, cybernetic upgrades, data intel
+
+### Urban Arc
+- Core mechanism: anomalous event investigation, urban legend decoding, social rule game, hidden identity
+- NPC focus: insider ordinary person / other supernatural / official agency
+- Rule design: "cannot expose anomaly" key constraint
+- Reward direction: intel clues, social resources, special items
+
+### Horror Arc
+- Core mechanism: survival escape, rule following, sanity management, unspeakable pursuit
+- NPC focus: encounterees (mad / going mad / survivor), "residents" in arc
+- Rule design: complex but not redundant (cannot look back / cannot speak / cannot trust mirrors)
+- Reward direction: survival itself is reward, special knowledge / items
+
+### Post-Apocalyptic Arc
+- Core mechanism: resource management (food / water / ammo / medicine), base defense, mutant confrontation, survivor socializing
+- NPC focus: other survivor groups, base leaders, mutants / infected
+- Rule design: absolute resource scarcity, moral gray zone, "humans worse than monsters"
+- Reward direction: survival supplies, weapons, intel, base migration permit
+
+## Constraints
+
+- ❌ Do not design multiple arcs in one interaction
+- ❌ Do not auto-fill "recommended reward values" without user request
+- ❌ Do not make rules too complex (more than 10 special rules hard to remember)
+- ❌ Do not make completion paths contradict each other
+- ❌ Do not design "only protagonist can complete" arcs
+- ✅ Each path must have different experience
+- ✅ Ensure sealing rules match arc theme
+- ✅ Encourage user to add personal style
+- ✅ Design at least one "high IQ solution" path
+- ✅ Mark impact of each design choice on subsequent plot