Shared World

#!/usr/bin/env -S deno run --allow-read --allow-write

/**
 * add-entry.ts - Add a new entry to the world bible
 *
 * Creates a new entry from template with proper metadata.
 *
 * Usage:
 *   deno run --allow-read --allow-write add-entry.ts \
 *     --bible ./world-bible \
 *     --category character \
 *     --name "Character Name" \
 *     --status proposed \
 *     --contributor "Your Name"
 */

const CATEGORIES = [
  'character', 'characters',
  'location', 'locations',
  'faction', 'factions',
  'event', 'events',
  'rule', 'rules',
  'culture', 'cultures',
  'artifact', 'artifacts',
  'species',
];

const STATUSES = ['established', 'proposed', 'deprecated', 'contradicted', 'speculative'];

interface EntryOptions {
  bible: string;
  category: string;
  name: string;
  status: string;
  contributor: string;
}

function getDate(): string {
  return new Date().toISOString().split('T')[0];
}

function slugify(name: string): string {
  return name.toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/(^-|-$)/g, '');
}

function normalizeCategory(category: string): string {
  const singular = category.endsWith('s') ? category.slice(0, -1) : category;
  const plural = singular + 's';

  // Special case for species
  if (singular === 'specie') return 'species';

  return plural;
}

function getStatusSymbol(status: string): string {
  switch (status.toLowerCase()) {
    case 'established': return '✓';
    case 'proposed': return '?';
    case 'deprecated': return '✗';
    case 'contradicted': return '⚠';
    case 'speculative': return '~';
    default: return '?';
  }
}

function generateEntry(options: EntryOptions): string {
  const date = getDate();
  const statusCapitalized = options.status.charAt(0).toUpperCase() + options.status.slice(1);
  const categoryCapitalized = options.category.charAt(0).toUpperCase() + options.category.slice(1);

  return `# ${options.name}

**Canon Status:** ${statusCapitalized}
**Category:** ${categoryCapitalized}
**Created:** ${date}
**Last Updated:** ${date}
**Contributors:** ${options.contributor}

## Summary

[1-2 sentence overview for quick reference]

## Description

[Detailed information about this entry]

## Relationships

- **Related To:** [[Related Entry]]
<!-- Add more relationships as appropriate:
- **Located In:** [[Location]]
- **Member Of:** [[Faction]]
- **Contains:** [[Sub-entry]]
- **Preceded By:** [[Earlier Entry]]
- **See Also:** [[Related Entry]]
-->

## Key Facts

- [Key fact 1]
- [Key fact 2]
- [Key fact 3]

## Notes for Writers

[Guidance for using this element in stories. What should writers know? What's flexible vs. fixed?]

## Sources

- [Source work/document] (what was established)

## History

- ${date}: Created by ${options.contributor}
`;
}

function generateChangelogEntry(options: EntryOptions): string {
  const date = getDate();
  return `- **Created**: New ${options.category} entry "${options.name}" (${options.contributor})`;
}

async function addEntry(options: EntryOptions) {
  const category = normalizeCategory(options.category);
  const slug = slugify(options.name);
  const entryPath = `${options.bible}/${category}/${slug}.md`;
  const changelogPath = `${options.bible}/meta/changelog.md`;
  const indexPath = `${options.bible}/${category}/_index.md`;

  // Check if entry already exists
  try {
    await Deno.stat(entryPath);
    console.error(`Error: Entry already exists at ${entryPath}`);
    Deno.exit(1);
  } catch {
    // File doesn't exist, which is what we want
  }

  // Create the entry
  const entryContent = generateEntry(options);
  await Deno.writeTextFile(entryPath, entryContent);
  console.log(`Created: ${entryPath}`);

  // Update changelog
  try {
    let changelog = await Deno.readTextFile(changelogPath);
    const date = getDate();
    const changelogEntry = generateChangelogEntry(options);

    // Find today's date section or create it
    if (changelog.includes(`## ${date}`)) {
      // Add under existing date
      changelog = changelog.replace(
        `## ${date}\n`,
        `## ${date}\n\n${changelogEntry}\n`
      );
    } else {
      // Add new date section after the header
      const headerEnd = changelog.indexOf('\n## ');
      if (headerEnd > -1) {
        changelog = changelog.slice(0, headerEnd) +
          `\n## ${date}\n\n${changelogEntry}\n` +
          changelog.slice(headerEnd);
      }
    }

    await Deno.writeTextFile(changelogPath, changelog);
    console.log(`Updated: ${changelogPath}`);
  } catch (e) {
    console.warn(`Warning: Could not update changelog: ${e}`);
  }

  // Update index
  try {
    let index = await Deno.readTextFile(indexPath);
    const statusSymbol = getStatusSymbol(options.status);
    const newRow = `| [[${options.name}]] | ${statusSymbol} | [Add summary] |`;

    // Replace "no entries" row or add to table
    if (index.includes('*No entries yet*')) {
      index = index.replace('| *No entries yet* | | |', newRow);
    } else {
      // Add before the last empty line of the table
      const tableEnd = index.lastIndexOf('\n\n## Adding');
      if (tableEnd > -1) {
        index = index.slice(0, tableEnd) + '\n' + newRow + index.slice(tableEnd);
      }
    }

    await Deno.writeTextFile(indexPath, index);
    console.log(`Updated: ${indexPath}`);
  } catch (e) {
    console.warn(`Warning: Could not update index: ${e}`);
  }

  console.log(`
Entry created successfully!

Next steps:
1. Edit ${entryPath} to fill in details
2. Add wiki-links to related entries
3. Update the summary in ${indexPath}
`);
}

function parseArgs(args: string[]): EntryOptions | null {
  const options: Partial<EntryOptions> = {
    bible: './world-bible',
    status: 'proposed',
    contributor: 'Unknown',
  };

  for (let i = 0; i < args.length; i++) {
    switch (args[i]) {
      case '--bible':
      case '-b':
        options.bible = args[++i];
        break;
      case '--category':
      case '-c':
        options.category = args[++i];
        break;
      case '--name':
      case '-n':
        options.name = args[++i];
        break;
      case '--status':
      case '-s':
        options.status = args[++i];
        break;
      case '--contributor':
      case '--author':
      case '-a':
        options.contributor = args[++i];
        break;
    }
  }

  if (!options.category || !options.name) {
    return null;
  }

  if (!CATEGORIES.includes(options.category.toLowerCase())) {
    console.error(`Invalid category: ${options.category}`);
    console.error(`Valid categories: ${CATEGORIES.filter(c => !c.endsWith('s')).join(', ')}`);
    return null;
  }

  if (!STATUSES.includes(options.status!.toLowerCase())) {
    console.error(`Invalid status: ${options.status}`);
    console.error(`Valid statuses: ${STATUSES.join(', ')}`);
    return null;
  }

  return options as EntryOptions;
}

function showUsage() {
  console.log(`
Add Entry to World Bible
========================

Creates a new entry from template.

Usage:
  deno run --allow-read --allow-write add-entry.ts [options]

Options:
  --bible, -b       Path to world bible (default: ./world-bible)
  --category, -c    Entry category (required)
  --name, -n        Entry name (required)
  --status, -s      Canon status (default: proposed)
  --contributor, -a Contributor name (default: Unknown)

Categories:
  character, location, faction, event, rule, culture, artifact, species

Statuses:
  established, proposed, deprecated, contradicted, speculative

Example:
  deno run --allow-read --allow-write add-entry.ts \\
    --bible ./my-world \\
    --category character \\
    --name "Elena Blackwood" \\
    --status proposed \\
    --contributor "jsmith"
`);
}

async function main() {
  const args = Deno.args;

  if (args.length === 0 || args.includes('--help') || args.includes('-h')) {
    showUsage();
    Deno.exit(0);
  }

  const options = parseArgs(args);
  if (!options) {
    showUsage();
    Deno.exit(1);
  }

  try {
    await addEntry(options);
  } catch (e) {
    console.error('Error adding entry:', e);
    Deno.exit(1);
  }
}

main();

#!/usr/bin/env -S deno run --allow-read --allow-write

/**
 * build-index.ts - Rebuild index files from entries
 *
 * Scans all entries in a category and regenerates the _index.md file.
 *
 * Usage:
 *   deno run --allow-read --allow-write build-index.ts ./world-bible
 *   deno run --allow-read --allow-write build-index.ts ./world-bible --category characters
 */

import { walk } from "https://deno.land/std@0.208.0/fs/walk.ts";

interface EntryInfo {
  name: string;
  file: string;
  status: string;
  summary: string;
}

const CATEGORY_DESCRIPTIONS: Record<string, string> = {
  characters: 'People and beings that inhabit this world.',
  locations: 'Places in the world, from continents to individual buildings.',
  factions: 'Organizations, governments, groups, and alliances.',
  rules: 'How the world works - magic systems, technology, physics.',
  culture: 'Beliefs, customs, languages, and traditions.',
  artifacts: 'Significant objects, weapons, and items of power.',
  species: 'Non-human beings, creatures, and races.',
};

function getStatusSymbol(status: string): string {
  const lower = status.toLowerCase();
  if (lower.includes('established')) return '✓';
  if (lower.includes('proposed')) return '?';
  if (lower.includes('deprecated')) return '✗';
  if (lower.includes('contradicted')) return '⚠';
  if (lower.includes('speculative')) return '~';
  return '?';
}

function getDate(): string {
  return new Date().toISOString().split('T')[0];
}

async function parseEntry(path: string): Promise<EntryInfo | null> {
  try {
    const content = await Deno.readTextFile(path);

    // Extract name from first heading
    const nameMatch = content.match(/^#\s+(.+)$/m);
    if (!nameMatch) return null;

    const name = nameMatch[1].trim();

    // Extract status
    const statusMatch = content.match(/\*\*Canon Status:\*\*\s*(\w+)/);
    const status = statusMatch ? statusMatch[1] : 'Proposed';

    // Extract summary (first line after ## Summary)
    const summaryMatch = content.match(/## Summary\s*\n+([^\n#]+)/);
    let summary = summaryMatch ? summaryMatch[1].trim() : '';

    // Clean up placeholder text
    if (summary.startsWith('[') || summary === '') {
      summary = '[Add summary]';
    }

    // Truncate long summaries
    if (summary.length > 60) {
      summary = summary.slice(0, 57) + '...';
    }

    return {
      name,
      file: path,
      status,
      summary,
    };
  } catch {
    return null;
  }
}

async function buildCategoryIndex(biblePath: string, category: string): Promise<number> {
  const categoryPath = `${biblePath}/${category}`;
  const indexPath = `${categoryPath}/_index.md`;

  // Check if category directory exists
  try {
    await Deno.stat(categoryPath);
  } catch {
    return 0;
  }

  // Collect all entries
  const entries: EntryInfo[] = [];

  for await (const file of walk(categoryPath, {
    maxDepth: 1,
    exts: ['.md'],
  })) {
    if (file.isFile && !file.name.startsWith('_') && file.name !== 'overview.md') {
      const entry = await parseEntry(file.path);
      if (entry) {
        entries.push(entry);
      }
    }
  }

  // Sort alphabetically
  entries.sort((a, b) => a.name.localeCompare(b.name));

  // Generate index content
  const description = CATEGORY_DESCRIPTIONS[category] || `Entries in the ${category} category.`;
  const singular = category.endsWith('s') ? category.slice(0, -1) : category;

  let content = `# ${category.charAt(0).toUpperCase() + category.slice(1)}

${description}

## Entries

| Name | Status | Summary |
|------|--------|---------|
`;

  if (entries.length === 0) {
    content += `| *No entries yet* | | |\n`;
  } else {
    for (const entry of entries) {
      const symbol = getStatusSymbol(entry.status);
      content += `| [[${entry.name}]] | ${symbol} | ${entry.summary} |\n`;
    }
  }

  content += `
## Adding New ${category.charAt(0).toUpperCase() + category.slice(1)}

1. Create file in this directory: \`${singular}-name.md\`
2. Use the entry template
3. Set category to "${category.charAt(0).toUpperCase() + category.slice(1)}"
4. Add relationships to existing entries
5. Update this index
6. Note in [changelog](../meta/changelog.md)

---

*Last updated: ${getDate()}*
*Entries: ${entries.length}*
`;

  await Deno.writeTextFile(indexPath, content);
  return entries.length;
}

async function buildAllIndexes(biblePath: string): Promise<void> {
  const categories = Object.keys(CATEGORY_DESCRIPTIONS);
  let totalEntries = 0;

  console.log(`Building indexes for ${biblePath}...\n`);

  for (const category of categories) {
    const count = await buildCategoryIndex(biblePath, category);
    console.log(`  ${category}/_index.md: ${count} entries`);
    totalEntries += count;
  }

  console.log(`\nTotal entries indexed: ${totalEntries}`);
}

function showUsage() {
  console.log(`
Build World Bible Indexes
=========================

Regenerates _index.md files from entries.

Usage:
  deno run --allow-read --allow-write build-index.ts <world-bible-path>
  deno run --allow-read --allow-write build-index.ts <world-bible-path> --category <name>

Options:
  --category, -c    Only rebuild specific category index

Categories:
  characters, locations, factions, rules, culture, artifacts, species

Example:
  deno run --allow-read --allow-write build-index.ts ./world-bible
  deno run --allow-read --allow-write build-index.ts ./world-bible -c characters
`);
}

async function main() {
  const args = Deno.args;

  if (args.length === 0 || args.includes('--help') || args.includes('-h')) {
    showUsage();
    Deno.exit(0);
  }

  const biblePath = args[0];

  // Check if path exists
  try {
    await Deno.stat(biblePath);
  } catch {
    console.error(`Error: Path not found: ${biblePath}`);
    Deno.exit(1);
  }

  // Check for specific category
  const categoryIndex = args.indexOf('--category');
  const categoryIndexShort = args.indexOf('-c');
  const catIdx = categoryIndex > -1 ? categoryIndex : categoryIndexShort;

  if (catIdx > -1 && args[catIdx + 1]) {
    const category = args[catIdx + 1];
    console.log(`Building index for ${category}...`);
    const count = await buildCategoryIndex(biblePath, category);
    console.log(`${category}/_index.md: ${count} entries`);
  } else {
    await buildAllIndexes(biblePath);
  }
}

main();

#!/usr/bin/env -S deno run --allow-read

/**
 * check-conflicts.ts - Scan world bible for potential conflicts
 *
 * Identifies:
 * - Entries marked as contradicted
 * - Broken wiki-links
 * - Duplicate entry names
 * - Entries without sources
 *
 * Usage:
 *   deno run --allow-read check-conflicts.ts ./world-bible
 */

import { walk } from "https://deno.land/std@0.208.0/fs/walk.ts";

interface Issue {
  type: 'contradiction' | 'broken-link' | 'duplicate' | 'missing-source' | 'orphan';
  file: string;
  description: string;
  severity: 'error' | 'warning' | 'info';
}

interface ScanResult {
  files: number;
  entries: Map<string, string[]>; // name -> files containing it
  links: Set<string>;
  issues: Issue[];
}

async function scanFile(path: string, result: ScanResult): Promise<void> {
  const content = await Deno.readTextFile(path);
  const lines = content.split('\n');

  // Extract entry name from first heading
  const nameMatch = content.match(/^#\s+(.+)$/m);
  if (nameMatch) {
    const name = nameMatch[1].trim();
    if (!result.entries.has(name)) {
      result.entries.set(name, []);
    }
    result.entries.get(name)!.push(path);
  }

  // Check for contradicted status
  if (content.includes('**Canon Status:** Contradicted') ||
      content.includes('Status:** ⚠')) {
    result.issues.push({
      type: 'contradiction',
      file: path,
      description: 'Entry is marked as contradicted - needs resolution',
      severity: 'error',
    });
  }

  // Extract wiki-links
  const linkPattern = /\[\[([^\]|]+)(?:\|[^\]]+)?\]\]/g;
  let match;
  while ((match = linkPattern.exec(content)) !== null) {
    result.links.add(match[1].trim());
  }

  // Check for missing sources
  if (content.includes('## Sources') &&
      (content.includes('[Source work/document]') ||
       content.match(/## Sources\s*\n\s*\n/))) {
    result.issues.push({
      type: 'missing-source',
      file: path,
      description: 'Entry has no sources documented',
      severity: 'warning',
    });
  }

  // Check for unfilled template markers
  if (content.includes('[1-2 sentence overview') ||
      content.includes('[Detailed information about') ||
      content.includes('[Key fact')) {
    result.issues.push({
      type: 'orphan',
      file: path,
      description: 'Entry has unfilled template sections',
      severity: 'info',
    });
  }

  result.files++;
}

async function scanWorldBible(biblePath: string): Promise<ScanResult> {
  const result: ScanResult = {
    files: 0,
    entries: new Map(),
    links: new Set(),
    issues: [],
  };

  for await (const entry of walk(biblePath, {
    exts: ['.md'],
    skip: [/node_modules/, /\.git/],
  })) {
    if (entry.isFile && !entry.name.startsWith('_')) {
      await scanFile(entry.path, result);
    }
  }

  // Check for duplicates
  for (const [name, files] of result.entries) {
    if (files.length > 1) {
      result.issues.push({
        type: 'duplicate',
        file: files.join(', '),
        description: `Duplicate entry name "${name}" in multiple files`,
        severity: 'error',
      });
    }
  }

  // Check for broken links
  for (const link of result.links) {
    // Skip section links
    if (link.includes('#')) continue;

    // Check if link target exists
    if (!result.entries.has(link)) {
      result.issues.push({
        type: 'broken-link',
        file: 'Multiple files',
        description: `Broken link: [[${link}]] - no entry with this name`,
        severity: 'warning',
      });
    }
  }

  return result;
}

function formatReport(result: ScanResult): string {
  let report = `
WORLD BIBLE CONFLICT CHECK
==========================

Files scanned: ${result.files}
Unique entries: ${result.entries.size}
Wiki-links found: ${result.links.size}

`;

  const errors = result.issues.filter(i => i.severity === 'error');
  const warnings = result.issues.filter(i => i.severity === 'warning');
  const infos = result.issues.filter(i => i.severity === 'info');

  if (errors.length > 0) {
    report += `ERRORS (${errors.length})\n${'='.repeat(40)}\n\n`;
    for (const issue of errors) {
      report += `[${issue.type.toUpperCase()}] ${issue.description}\n`;
      report += `  File: ${issue.file}\n\n`;
    }
  }

  if (warnings.length > 0) {
    report += `WARNINGS (${warnings.length})\n${'='.repeat(40)}\n\n`;
    for (const issue of warnings) {
      report += `[${issue.type.toUpperCase()}] ${issue.description}\n`;
      report += `  File: ${issue.file}\n\n`;
    }
  }

  if (infos.length > 0) {
    report += `INFO (${infos.length})\n${'='.repeat(40)}\n\n`;
    for (const issue of infos) {
      report += `[${issue.type.toUpperCase()}] ${issue.description}\n`;
      report += `  File: ${issue.file}\n\n`;
    }
  }

  if (result.issues.length === 0) {
    report += `No issues found.\n`;
  } else {
    report += `
SUMMARY
=======
Errors: ${errors.length}
Warnings: ${warnings.length}
Info: ${infos.length}
Total: ${result.issues.length}
`;
  }

  return report;
}

function showUsage() {
  console.log(`
World Bible Conflict Check
==========================

Scans for potential conflicts and issues.

Usage:
  deno run --allow-read check-conflicts.ts <world-bible-path>

Checks for:
  - Entries marked as contradicted
  - Broken wiki-links ([[Name]] with no matching entry)
  - Duplicate entry names
  - Missing source documentation
  - Unfilled template sections

Example:
  deno run --allow-read check-conflicts.ts ./world-bible
`);
}

async function main() {
  const args = Deno.args;

  if (args.length === 0 || args.includes('--help') || args.includes('-h')) {
    showUsage();
    Deno.exit(0);
  }

  const biblePath = args[0];

  try {
    await Deno.stat(biblePath);
  } catch {
    console.error(`Error: Path not found: ${biblePath}`);
    Deno.exit(1);
  }

  const result = await scanWorldBible(biblePath);
  console.log(formatReport(result));

  // Exit with error code if errors found
  const errorCount = result.issues.filter(i => i.severity === 'error').length;
  if (errorCount > 0) {
    Deno.exit(1);
  }
}

main();

#!/usr/bin/env -S deno run --allow-read --allow-write

/**
 * init-world.ts - Initialize a new world bible structure
 *
 * Creates the full directory structure with template files
 * for a wiki-style world bible.
 *
 * Usage:
 *   deno run --allow-read --allow-write init-world.ts "World Name" [output-dir]
 *
 * Example:
 *   deno run --allow-read --allow-write init-world.ts "The Shattered Realms"
 *   deno run --allow-read --allow-write init-world.ts "My World" ./worlds/my-world
 */

const DIRECTORIES = [
  'characters',
  'locations',
  'history',
  'history/eras',
  'history/events',
  'factions',
  'rules',
  'culture',
  'artifacts',
  'species',
  'meta',
];

function getDate(): string {
  return new Date().toISOString().split('T')[0];
}

function slugify(name: string): string {
  return name.toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/(^-|-$)/g, '');
}

function generateDiscovery(worldName: string): string {
  return `# ${worldName} World Bible

Welcome to the canonical reference for ${worldName}. This world bible contains all established facts, proposed additions, and organizational structure for our shared world.

## Quick Start

1. **New here?** Start with [Style Guide](meta/style-guide.md) for conventions
2. **Looking for something?** Check the category indexes below
3. **Adding content?** Use [Add Entry](#adding-entries) workflow
4. **Found a conflict?** Report in [Conflicts](meta/conflicts.md)

## Canon Status Guide

| Symbol | Status | Meaning |
|--------|--------|---------|
| ✓ | Established | Confirmed canon - treat as fact |
| ? | Proposed | Suggested - available but may change |
| ✗ | Deprecated | Superseded - don't use in new work |
| ⚠ | Contradicted | Conflicts exist - needs resolution |
| ~ | Speculative | Extrapolated - use cautiously |

See [Canon Status](canon-status.md) for current overview.

## Categories

### [Characters](characters/_index.md)
People and beings in the world.

### [Locations](locations/_index.md)
Places, from continents to rooms.

### [History](history/timeline.md)
Timeline, eras, and significant events.

### [Factions](factions/_index.md)
Organizations, governments, and groups.

### [Rules](rules/_index.md)
How the world works - magic, technology, physics.

### [Culture](culture/_index.md)
Beliefs, customs, languages, traditions.

### [Artifacts](artifacts/_index.md)
Significant objects.

### [Species](species/_index.md)
Non-human beings and creatures.

## Adding Entries

1. Create entry using appropriate template
2. Set status to **Proposed**
3. Add relationships (wiki-links)
4. Update relevant index
5. Note in [Changelog](meta/changelog.md)

Proposed entries become Established after review by canon authority.

## Recent Changes

See [Changelog](meta/changelog.md) for recent updates.

## Conflicts

See [Conflicts](meta/conflicts.md) for unresolved contradictions.

## Contributors

See [Contributors](meta/contributors.md) for who maintains what.

---

*Created: ${getDate()}*
`;
}

function generateCanonStatus(worldName: string): string {
  return `# ${worldName} Canon Status

Overview of canonical state across all categories.

## Status Summary

| Category | Established | Proposed | Deprecated | Contradicted |
|----------|-------------|----------|------------|--------------|
| Characters | 0 | 0 | 0 | 0 |
| Locations | 0 | 0 | 0 | 0 |
| History | 0 | 0 | 0 | 0 |
| Factions | 0 | 0 | 0 | 0 |
| Rules | 0 | 0 | 0 | 0 |
| Culture | 0 | 0 | 0 | 0 |
| Artifacts | 0 | 0 | 0 | 0 |
| Species | 0 | 0 | 0 | 0 |

## Recent Status Changes

*No changes yet.*

## Pending Review

Proposed entries awaiting establishment:

*None yet.*

---

*Last updated: ${getDate()}*
`;
}

function generateIndex(category: string, description: string): string {
  const singular = category.endsWith('s') ? category.slice(0, -1) : category;
  return `# ${category.charAt(0).toUpperCase() + category.slice(1)}

${description}

## Entries

| Name | Status | Summary |
|------|--------|---------|
| *No entries yet* | | |

## Adding New ${category.charAt(0).toUpperCase() + category.slice(1)}

1. Create file in this directory: \`${singular}-name.md\`
2. Use the entry template
3. Set category to "${category.charAt(0).toUpperCase() + category.slice(1)}"
4. Add relationships to existing entries
5. Update this index
6. Note in [changelog](../meta/changelog.md)

---

*Last updated: ${getDate()}*
`;
}

function generateTimeline(): string {
  return `# Timeline

Chronological overview of ${getDate()}'s history.

## Eras

| Era | Period | Description |
|-----|--------|-------------|
| *Define eras as needed* | | |

## Major Events

See [events/](events/) for detailed event entries.

## Adding to Timeline

1. Create event entry in \`events/\` directory
2. Add to appropriate era section above
3. Update [changelog](../meta/changelog.md)

---

*Last updated: ${getDate()}*
`;
}

function generateStyleGuide(worldName: string): string {
  return `# ${worldName} Style Guide

Guidelines for contributing to this shared world.

## Naming Conventions

### Characters
- [Describe naming patterns, cultural influences]
- [Examples of good names]

### Places
- [Describe place naming conventions]
- [Linguistic patterns]

### Organizations
- [How factions/groups are named]

## Tone and Voice

### World Tone
[Describe the overall feel - dark, hopeful, gritty, whimsical, etc.]

### What Fits
- [Elements that belong]
- [Themes that work]

### What Doesn't Fit
- [Elements to avoid]
- [Tone mismatches]

## Content Boundaries

### Acceptable Content
- [What can be depicted]
- [How to handle sensitive topics]

### Requires Care
- [Topics needing sensitivity]
- [How to approach them]

### Off-Limits
- [Topics not allowed]
- [Hard boundaries]

## Formatting Standards

### Dates
- In-world calendar: [describe]
- Out-of-world: YYYY-MM-DD

### Measurements
- [Units used in-world]
- [Conversion notes if helpful]

### Capitalization
- [What gets capitalized]
- [Title conventions]

## Common Terms

| Term | Meaning | Usage |
|------|---------|-------|
| [Term] | [Definition] | [How to use] |

## Canon Authority

Primary canon authority: [Name/Role]

Decisions logged in: [conflicts.md](conflicts.md)

---

*Established: ${getDate()}*
`;
}

function generateChangelog(worldName: string): string {
  return `# ${worldName} Changelog

Recent changes to the world bible.

## ${getDate()}

- **Created**: World bible initialized

---

## Adding to Changelog

When you make changes:
1. Add entry under today's date (or create new date header)
2. Use format: \`- **Action**: Description (contributor)\`
3. Actions: Created, Updated, Deprecated, Established, Resolved

Example:
\`\`\`
- **Created**: New character entry for Elena (jsmith)
- **Updated**: Expanded magic system rules (kdoe)
- **Established**: Proposed faction "The Order" now canon (admin)
\`\`\`
`;
}

function generateConflicts(): string {
  return `# Canon Conflicts

Unresolved contradictions requiring attention.

## Active Conflicts

*No conflicts currently.*

## Resolved Conflicts

*No resolutions yet.*

---

## Reporting Conflicts

When you find contradicting information:

1. Add to Active Conflicts section below
2. Include:
   - Both entries involved (with links)
   - Nature of contradiction
   - Source references
   - Date discovered

### Template:

\`\`\`
### [Brief Description]
**Discovered:** [Date]
**Entries:** [[Entry 1]] vs [[Entry 2]]
**Conflict:** [Description of contradiction]
**Sources:**
- Entry 1: [source]
- Entry 2: [source]
**Status:** Awaiting resolution
\`\`\`

## Resolving Conflicts

Canon authority resolves by:
1. Determining which source has priority
2. Either reconciling both or deprecating one
3. Moving to Resolved section with decision documented
`;
}

function generateContributors(): string {
  return `# Contributors

Who maintains what in this world bible.

## Canon Authority

- **Primary:** [Name] - final decisions on canon status

## Active Contributors

| Name | Areas | Since |
|------|-------|-------|
| [Name] | [Categories/areas] | ${getDate()} |

## Contribution History

See [changelog](changelog.md) for detailed contribution history.

---

## Becoming a Contributor

1. Read the [Style Guide](style-guide.md)
2. Familiarize yourself with existing canon
3. Start with Proposed entries in your area of interest
4. Contact canon authority for questions
`;
}

const INDEX_DESCRIPTIONS: Record<string, string> = {
  characters: 'People and beings that inhabit this world.',
  locations: 'Places in the world, from continents to individual buildings.',
  factions: 'Organizations, governments, groups, and alliances.',
  rules: 'How the world works - magic systems, technology, physics.',
  culture: 'Beliefs, customs, languages, and traditions.',
  artifacts: 'Significant objects, weapons, and items of power.',
  species: 'Non-human beings, creatures, and races.',
};

async function initWorld(worldName: string, outputDir: string) {
  console.log(`Initializing world bible for "${worldName}"...`);
  console.log(`Output directory: ${outputDir}`);

  // Create directories
  await Deno.mkdir(outputDir, { recursive: true });
  for (const dir of DIRECTORIES) {
    await Deno.mkdir(`${outputDir}/${dir}`, { recursive: true });
    console.log(`  Created: ${dir}/`);
  }

  // Create main files
  await Deno.writeTextFile(`${outputDir}/discovery.md`, generateDiscovery(worldName));
  console.log('  Created: discovery.md');

  await Deno.writeTextFile(`${outputDir}/canon-status.md`, generateCanonStatus(worldName));
  console.log('  Created: canon-status.md');

  // Create index files
  for (const [category, description] of Object.entries(INDEX_DESCRIPTIONS)) {
    await Deno.writeTextFile(
      `${outputDir}/${category}/_index.md`,
      generateIndex(category, description)
    );
    console.log(`  Created: ${category}/_index.md`);
  }

  // Create history timeline
  await Deno.writeTextFile(`${outputDir}/history/timeline.md`, generateTimeline());
  console.log('  Created: history/timeline.md');

  // Create meta files
  await Deno.writeTextFile(`${outputDir}/meta/style-guide.md`, generateStyleGuide(worldName));
  console.log('  Created: meta/style-guide.md');

  await Deno.writeTextFile(`${outputDir}/meta/changelog.md`, generateChangelog(worldName));
  console.log('  Created: meta/changelog.md');

  await Deno.writeTextFile(`${outputDir}/meta/conflicts.md`, generateConflicts());
  console.log('  Created: meta/conflicts.md');

  await Deno.writeTextFile(`${outputDir}/meta/contributors.md`, generateContributors());
  console.log('  Created: meta/contributors.md');

  console.log(`
World bible initialized!

Next steps:
1. Edit meta/style-guide.md with your world's conventions
2. Add yourself to meta/contributors.md
3. Start adding entries to populate the bible
4. Use discovery.md as your navigation hub
`);
}

function showUsage() {
  console.log(`
Initialize World Bible
======================

Creates a complete world bible directory structure.

Usage:
  deno run --allow-read --allow-write init-world.ts "World Name" [output-dir]

Arguments:
  World Name    Name of your world (required)
  output-dir    Where to create the bible (default: ./world-bible)

Examples:
  deno run --allow-read --allow-write init-world.ts "The Shattered Realms"
  deno run --allow-read --allow-write init-world.ts "My World" ./worlds/my-world
`);
}

async function main() {
  const args = Deno.args;

  if (args.length === 0 || args[0] === '--help' || args[0] === '-h') {
    showUsage();
    Deno.exit(0);
  }

  const worldName = args[0];
  const outputDir = args[1] || `./world-bible`;

  try {
    await initWorld(worldName, outputDir);
  } catch (e) {
    console.error('Error initializing world bible:', e);
    Deno.exit(1);
  }
}

main();