geowiki-cli 1.0.1

package/cli/commands/doc.js

@@ -0,0 +1,380 @@
+/**
+ * Document management commands
+ * Usage: geo doc [create|list|get|update|delete] [options]
+ */
+
+import { extractArg, hasFlag } from '../utils/args.js';
+import { apiGet, apiPost, apiPut, apiDelete, getBaseUrl } from '../utils/api.js';
+import { outputJson, outputSuccess } from '../utils/output.js';
+import { dispatch } from '../utils/dispatch.js';
+import fs from 'fs';
+import path from 'path';
+import matter from 'gray-matter';
+import readline from 'readline';
+
+export async function doc(args) {
+  const result = dispatch(args, actions, ['create', 'list', 'get', 'update', 'delete', 'reorder', 'trash', 'recover'], printDocHelp);
+  if (result) await actions[result.action](result.subArgs);
+}
+
+const actions = {
+  async create(args) {
+    const file = extractArg(args, '--file') || extractArg(args, '-f');
+    const title = extractArg(args, '--title') || extractArg(args, '-t');
+    const slug = extractArg(args, '--slug') || extractArg(args, '-s');
+    const category = extractArg(args, '--category') || extractArg(args, '-c');
+    const lang = extractArg(args, '--lang') || extractArg(args, '-l') || 'zh';
+    const tags = extractArg(args, '--tags') || extractArg(args, '-T');
+    let description = extractArg(args, '--description') || extractArg(args, '-d');
+    const author = extractArg(args, '--author') || extractArg(args, '-a') || 'Agent';
+    const sort = extractArg(args, '--sort');
+    const asDraft = hasFlag(args, '--draft');
+    const json = hasFlag(args, '--json');
+
+    if (!file && !title) {
+      console.error('Error: --file or --title is required');
+      process.exit(1);
+    }
+
+    let content = '';
+    let docTitle = title || '';
+    let docSlug = slug;
+    let docCategory = category;
+    let docTags = tags;
+    let docAuthor = author;
+    let docSort = sort;
+
+    if (file) {
+      if (!fs.existsSync(file)) {
+        console.error(`File not found: ${file}`);
+        process.exit(1);
+      }
+      const raw = fs.readFileSync(file, 'utf-8');
+      const parsed = matter(raw);
+      content = parsed.content;
+      const fm = parsed.data || {};
+
+      docTitle = docTitle || fm.title || '';
+      docSlug = docSlug || fm.slug;
+      docCategory = docCategory || fm.category;
+      docTags = docTags || (Array.isArray(fm.tags) ? fm.tags.join(', ') : undefined);
+      docAuthor = docAuthor !== 'Agent' ? docAuthor : (fm.author || docAuthor);
+      if (docSort == null && fm.sort != null) docSort = String(fm.sort);
+      if (!description && fm.description) description = fm.description;
+    }
+
+    if (!description && content) {
+      const bodyOnly = content.replace(/^---[\s\S]*?---\s*/, '');
+      description = bodyOnly.replace(/[\][#*`]/g, '').replace(/\n+/g, ' ').trim().substring(0, 100);
+    }
+
+    // Generate slug: use provided slug, or derive from title
+    let generatedSlug = docSlug;
+    if (!generatedSlug) {
+      generatedSlug = docTitle
+        .toLowerCase()
+        .replace(/\s+/g, '-')
+        .replace(/[^a-z0-9-]/g, '')
+        .replace(/-+/g, '-')
+        .replace(/^-|-$/g, '');
+      // If slug is empty after stripping (e.g., all Chinese), use timestamp fallback
+      if (!generatedSlug) {
+        generatedSlug = `doc-${Date.now()}`;
+      }
+    }
+
+    const payload = {
+      title: docTitle,
+      slug: generatedSlug,
+      category: docCategory || 'general',
+      tags: docTags ? docTags.split(',').map(t => t.trim()) : [],
+      author: docAuthor,
+      description: description || docTitle,
+      content,
+      language: lang,
+      draft: asDraft
+    };
+    if (docSort != null) {
+      const sortNum = Number(docSort);
+      if (!Number.isNaN(sortNum)) payload.sort = sortNum;
+    }
+
+    const data = await apiPost('/api/v1/admin/docs', payload);
+    const baseUrl = getBaseUrl();
+
+    outputSuccess(
+      `Document created successfully!\nSlug: ${data.data.slug}\nURL: ${baseUrl}/docs/${data.data.slug}`,
+      json,
+      { slug: data.data.slug, title: payload.title, url: `${baseUrl}/docs/${data.data.slug}` }
+    );
+  },
+
+  async list(args) {
+    const category = extractArg(args, '--category');
+    const lang = extractArg(args, '--lang') || extractArg(args, '-l') || 'zh';
+    const page = extractArg(args, '--page') || '1';
+    const limit = extractArg(args, '--limit') || '50';
+    const json = hasFlag(args, '--json');
+
+    let url = `/api/v1/docs?lang=${lang}&page=${page}&limit=${limit}`;
+    if (category) url += `&category=${encodeURIComponent(category)}`;
+
+    const data = await apiGet(url);
+    const docs = Array.isArray(data.data) ? data.data : [];
+
+    if (outputJson(docs, json)) return;
+
+    console.log(`\nDocuments (${docs.length} found):\n`);
+    docs.forEach(d => {
+      console.log(`  ${d.slug.padEnd(40)} | ${d.title}`);
+    });
+  },
+
+  async get(args) {
+    const slug = extractArg(args, '--slug') || extractArg(args, '-s');
+    const lang = extractArg(args, '--lang') || extractArg(args, '-l') || 'zh';
+    const format = extractArg(args, '--format') || extractArg(args, '-f') || 'markdown';
+    const json = hasFlag(args, '--json');
+
+    if (!slug) {
+      console.error('Error: --slug is required');
+      process.exit(1);
+    }
+
+    const data = await apiGet(`/api/v1/docs/${encodeURIComponent(slug)}?lang=${lang}`);
+
+    if (format === 'json' || json) {
+      console.log(JSON.stringify(data.data, null, 2));
+    } else {
+      const doc = data.data;
+      let md = `---\ntitle: "${doc.title}"\nslug: ${doc.slug}\ncategory: ${doc.category}\ntags: [${(doc.tags || []).join(', ')}]\n---\n\n`;
+      // Only add H1 if content doesn't already start with one
+      const content = doc.content || '';
+      if (!content.startsWith('# ')) {
+        md += `# ${doc.title}\n\n`;
+      }
+      md += content;
+      console.log(md);
+    }
+  },
+
+  async update(args) {
+    const slug = extractArg(args, '--slug') || extractArg(args, '-s');
+    const file = extractArg(args, '--file') || extractArg(args, '-f');
+    const content = extractArg(args, '--content');
+    const category = extractArg(args, '--category') || extractArg(args, '-c');
+    const lang = extractArg(args, '--lang') || extractArg(args, '-l') || 'zh';
+    const sort = extractArg(args, '--sort');
+    const contentOnly = hasFlag(args, '--content-only');
+    const asDraft = hasFlag(args, '--draft');
+    const json = hasFlag(args, '--json');
+
+    if (!slug) {
+      console.error('Error: --slug is required');
+      process.exit(1);
+    }
+
+    if (!file && !content && sort == null && !category) {
+      console.error('Error: --file, --content, --category, or --sort is required');
+      process.exit(1);
+    }
+
+    let body = {};
+    if (file) {
+      if (!fs.existsSync(file)) {
+        console.error(`File not found: ${file}`);
+        process.exit(1);
+      }
+      const raw = fs.readFileSync(file, 'utf-8');
+      const parsed = matter(raw);
+      body.content = parsed.content;
+      // Extract metadata from frontmatter (unless --content-only)
+      if (!contentOnly) {
+        const fm = parsed.data || {};
+        if (fm.title) body.title = fm.title;
+        if (fm.description) body.description = fm.description;
+        if (fm.category) body.category = fm.category;
+        if (fm.author) body.author = fm.author;
+        if (Array.isArray(fm.tags)) body.tags = fm.tags;
+        if (fm.sort !== undefined) body.sort = fm.sort;
+      }
+    }
+    if (content) body.content = content;
+    if (category) body.category = category;
+    if (sort != null) {
+      const sortNum = Number(sort);
+      if (Number.isNaN(sortNum)) {
+        console.error('Error: --sort must be a number');
+        process.exit(1);
+      }
+      body.sort = sortNum;
+    }
+
+    // Server reads req.body.language for the target language
+    body.language = lang;
+    if (asDraft) body.draft = true;
+
+    await apiPut(`/api/v1/admin/docs/${encodeURIComponent(slug)}?lang=${lang}`, body);
+    outputSuccess('Document updated successfully!', json, { slug });
+  },
+
+  async delete(args) {
+    const slug = extractArg(args, '--slug') || extractArg(args, '-s');
+    const lang = extractArg(args, '--lang') || extractArg(args, '-l') || 'zh';
+    const json = hasFlag(args, '--json');
+    const yes = hasFlag(args, '--yes') || hasFlag(args, '-y');
+
+    if (!slug) {
+      console.error('Error: --slug is required');
+      process.exit(1);
+    }
+
+    // Confirmation prompt
+    if (!yes && !json) {
+      const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+      const answer = await new Promise(resolve => {
+        rl.question(`⚠️  Delete "${slug}" (${lang})? This moves it to trash for 30 days. [y/N] `, resolve);
+      });
+      rl.close();
+      if (answer.toLowerCase() !== 'y' && answer.toLowerCase() !== 'yes') {
+        console.log('Cancelled.');
+        return;
+      }
+    }
+
+    // Server-side delete (server handles trash backup automatically)
+    await apiDelete(`/api/v1/admin/docs/${encodeURIComponent(slug)}?lang=${lang}`);
+    outputSuccess('Document deleted successfully! (moved to server trash)', json, { deleted: slug, language: lang });
+  },
+
+  async trash(args) {
+    const json = hasFlag(args, '--json');
+    const clear = hasFlag(args, '--clear');
+    const yes = hasFlag(args, '--yes') || hasFlag(args, '-y');
+
+    // Use server-side API
+    const data = await apiGet('/api/v1/admin/docs/trash');
+    const items = data.data || [];
+
+    if (json) {
+      outputJson({ trash: items });
+    } else {
+      if (items.length === 0) {
+        console.log('🗑️  Trash is empty.');
+      } else {
+        console.log(`\n🗑️  Trash (${items.length} items):\n`);
+        for (const item of items) {
+          const date = item.deleted_at ? new Date(item.deleted_at).toLocaleDateString() : '?';
+          console.log(`  ${item.slug} (${item.language}) — ${item.title} — deleted ${date}`);
+        }
+        console.log('\nRecover: geo doc recover --file <filename>');
+        console.log('Empty:   geo doc trash --clear');
+      }
+    }
+
+    // Handle --clear flag
+    if (clear) {
+      if (!yes && !json) {
+        const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+        const answer = await new Promise(resolve => {
+          rl.question(`⚠️  Permanently delete ${items.length} items from trash? [y/N] `, resolve);
+        });
+        rl.close();
+        if (answer.toLowerCase() !== 'y' && answer.toLowerCase() !== 'yes') {
+          console.log('Cancelled.');
+          return;
+        }
+      }
+      await apiDelete('/api/v1/admin/docs/trash');
+      if (!json) console.log(`🗑️  Cleared ${items.length} items from trash.`);
+    }
+  },
+
+  async recover(args) {
+    const file = extractArg(args, '--file') || extractArg(args, '-f');
+    const json = hasFlag(args, '--json');
+
+    if (!file) {
+      console.error('Error: --file is required (e.g. --file my-doc-zh-1234567890.md)');
+      console.error('Run "geo doc trash" to see available files.');
+      process.exit(1);
+    }
+
+    // Use server-side API
+    const result = await apiPost('/api/v1/admin/docs/trash/recover', { file });
+    const slug = result.data?.slug || file;
+    const lang = result.data?.language || 'zh';
+
+    outputSuccess('Document recovered successfully!', json, { slug, language: lang });
+  },
+
+  async reorder(args) {
+    const ordersFlag = extractArg(args, '--orders') || extractArg(args, '-o');
+    const json = hasFlag(args, '--json');
+
+    if (!ordersFlag) {
+      console.error('Error: --orders is required (e.g. --orders "slug1:0,slug2:1,slug3:2")');
+      process.exit(1);
+    }
+
+    const orders = ordersFlag.split(',').map(pair => {
+      const [slug, sort] = pair.split(':').map(s => s && s.trim());
+      const sortNum = Number(sort);
+      if (!slug || Number.isNaN(sortNum)) {
+        console.error(`Error: invalid pair "${pair}". Expected slug:sort.`);
+        process.exit(1);
+      }
+      return { slug, sort: sortNum };
+    });
+
+    await apiPut('/api/v1/admin/docs/reorder', { orders });
+    outputSuccess(`Reordered ${orders.length} documents`, json, { orders });
+  }
+};
+
+function printDocHelp() {
+  console.log(`
+Usage: geo doc <action> [options]
+
+Actions:
+  create    Create a new document
+  list      List documents
+  get       Get document content
+  update    Update a document
+  delete    Delete a document (moves to trash, language-specific)
+  trash     List or clear trash
+  recover   Recover a document from trash
+  reorder   Batch update sort order within a category
+
+Options:
+  --sort NUM           Document sort order (ascending, default 999)
+  --file,-f            File path for create/update
+  --content            Inline content for update
+  --content-only       Update content only (skip frontmatter metadata)
+  --slug,-s            Document slug
+  --category,-c        Category slug
+  --lang,-l            Language code (default: zh)
+  --title,-t           Document title (create only)
+  --tags,-T            Comma-separated tags
+  --description,-d     Short description
+  --author,-a          Author name (default: Agent)
+  --draft              Save as draft (skip publishing)
+  --yes,-y             Skip confirmation prompt (for scripting)
+  --json               Machine-readable JSON output
+
+Examples:
+  geo doc create --file ./product.md --category can-motion --sort 1
+  geo doc create --file ./draft.md --category new-cat --draft    # save as draft
+  geo doc update --slug product-slug --sort 2
+  geo doc list --category can-motion
+  geo doc get --slug uim2040cm
+  geo doc update --slug uim2040cm --content "Updated content"
+  geo doc delete --slug old-doc --lang zh        # moves to trash
+  geo doc delete --slug old-doc --lang zh --yes  # skip confirmation
+  geo doc trash                                  # list trash
+  geo doc trash --clear                          # empty trash (with confirmation)
+  geo doc trash --clear --yes                    # empty trash (skip confirmation)
+  geo doc recover --file old-doc-zh-123456.md   # recover from trash
+  geo doc reorder --orders "slug1:0,slug2:1,slug3:2"
+`);
+}

package/cli/commands/draft.js

@@ -0,0 +1,113 @@
+/**
+ * Draft management commands
+ * Usage: geo draft [list|get|publish|delete] [options]
+ */
+
+import { extractArg, hasFlag } from '../utils/args.js';
+import { apiGet, apiPost, apiDelete } from '../utils/api.js';
+import { outputJson, outputSuccess, confirmDelete } from '../utils/output.js';
+import { dispatch } from '../utils/dispatch.js';
+
+export async function draft(args) {
+  const result = dispatch(args, actions, ['list', 'get', 'publish', 'delete'], printDraftHelp);
+  if (result) await actions[result.action](result.subArgs);
+}
+
+const actions = {
+  async list(args) {
+    const json = hasFlag(args, '--json');
+
+    const data = await apiGet('/api/v1/admin/drafts');
+    const drafts = data.data || [];
+
+    if (outputJson(drafts, json)) return;
+
+    console.log(`\nDrafts (${drafts.length} found):\n`);
+    drafts.forEach(d => {
+      const lang = d.language || d.lang || '?';
+      const status = d.status || 'pending';
+      console.log(`  ${d.slug.padEnd(30)} | ${lang.padEnd(4)} | ${status.padEnd(10)} | ${d.title || ''}`);
+    });
+  },
+
+  async get(args) {
+    const slug = extractArg(args, '--slug') || extractArg(args, '-s');
+    const json = hasFlag(args, '--json');
+
+    if (!slug) {
+      console.error('Error: --slug is required');
+      process.exit(1);
+    }
+
+    const data = await apiGet(`/api/v1/admin/drafts/${encodeURIComponent(slug)}`);
+    const draft = data.data || {};
+
+    if (outputJson(draft, json)) return;
+
+    console.log(`\nDraft: ${draft.title || slug}\n`);
+    console.log(`  Slug: ${draft.slug}`);
+    console.log(`  Language: ${draft.language || draft.lang || '?'}`);
+    console.log(`  Status: ${draft.status || 'pending'}`);
+    if (draft.content) {
+      console.log(`\n--- Content ---\n`);
+      console.log(draft.content);
+    }
+  },
+
+  async publish(args) {
+    const slug = extractArg(args, '--slug') || extractArg(args, '-s');
+    const lang = extractArg(args, '--lang') || extractArg(args, '-l') || 'zh';
+    const json = hasFlag(args, '--json');
+
+    if (!slug) {
+      console.error('Error: --slug is required');
+      process.exit(1);
+    }
+
+    await apiPost(`/api/v1/admin/drafts/${encodeURIComponent(slug)}/publish`, { language: lang });
+    outputSuccess(`Draft published: ${slug}`, json, { slug, published: true, language: lang });
+  },
+
+  async delete(args) {
+    const slug = extractArg(args, '--slug') || extractArg(args, '-s');
+    const lang = extractArg(args, '--lang') || extractArg(args, '-l') || 'zh';
+    const json = hasFlag(args, '--json');
+
+    if (!slug) {
+      console.error('Error: --slug is required');
+      process.exit(1);
+    }
+
+    const confirmed = await confirmDelete(`Delete draft "${slug}"?`, args);
+    if (!confirmed) {
+      console.log('Cancelled.');
+      return;
+    }
+
+    await apiDelete(`/api/v1/admin/drafts/${encodeURIComponent(slug)}?lang=${lang}`);
+    outputSuccess(`Draft deleted: ${slug}`, json, { deleted: slug, language: lang });
+  }
+};
+
+function printDraftHelp() {
+  console.log(`
+Usage: geo draft <action> [options]
+
+Actions:
+  list       List all drafts
+  get        Get draft content
+  publish    Publish draft to production
+  delete     Delete/reject a draft
+
+Options:
+  --slug,-s          Draft slug (required for get/publish/delete)
+  --lang,-l          Language code (default: zh)
+  --json             Machine-readable JSON output
+
+Examples:
+  geo draft list --json
+  geo draft get --slug my-doc-draft --json
+  geo draft publish --slug my-doc-draft
+  geo draft delete --slug my-doc-draft
+`);
+}

package/cli/commands/feedback.js

@@ -0,0 +1,84 @@
+/**
+ * Feedback management commands
+ * Usage: geo feedback [list|delete|promote] [options]
+ */
+
+import { extractArg, hasFlag } from '../utils/args.js';
+import { apiGet, apiPost, apiDelete } from '../utils/api.js';
+import { outputJson, outputSuccess, confirmDelete } from '../utils/output.js';
+import { dispatch } from '../utils/dispatch.js';
+
+export async function feedback(args) {
+  const result = dispatch(args, actions, ['list', 'delete', 'promote'], printFeedbackHelp);
+  if (result) await actions[result.action](result.subArgs);
+}
+
+const actions = {
+  async list(args) {
+    const json = hasFlag(args, '--json');
+
+    const data = await apiGet('/api/v1/admin/feedback');
+    const items = data.data || [];
+
+    if (outputJson(items, json)) return;
+
+    console.log(`\nFeedback (${items.length} found):\n`);
+    items.forEach(f => {
+      const id = (f.id || f._id || '').toString().slice(0, 8);
+      const slug = f.docSlug || f.slug || '?';
+      console.log(`  ${id.padEnd(10)} | ${slug.padEnd(30)} | rating=${(f.rating || '?').toString().padEnd(4)} | ${(f.comment || '').substring(0, 40)}`);
+    });
+  },
+
+  async delete(args) {
+    const id = extractArg(args, '--id');
+    const json = hasFlag(args, '--json');
+
+    if (!id) {
+      console.error('Error: --id is required');
+      process.exit(1);
+    }
+
+    const confirmed = await confirmDelete(`Delete feedback "${id}"?`, args);
+    if (!confirmed) {
+      console.log('Cancelled.');
+      return;
+    }
+
+    await apiDelete(`/api/v1/admin/feedback/${encodeURIComponent(id)}`);
+    outputSuccess(`Feedback deleted: ${id}`, json, { deleted: id });
+  },
+
+  async promote(args) {
+    const id = extractArg(args, '--id');
+    const json = hasFlag(args, '--json');
+
+    if (!id) {
+      console.error('Error: --id is required');
+      process.exit(1);
+    }
+
+    await apiPost(`/api/v1/admin/feedback/${encodeURIComponent(id)}/promote`);
+    outputSuccess(`Feedback promoted: ${id}`, json, { id, promoted: true });
+  }
+};
+
+function printFeedbackHelp() {
+  console.log(`
+Usage: geo feedback <action> [options]
+
+Actions:
+  list       List all feedback entries
+  delete     Delete a feedback entry
+  promote    Promote feedback to document content or FAQ
+
+Options:
+  --id              Feedback ID (required for delete/promote)
+  --json            Machine-readable JSON output
+
+Examples:
+  geo feedback list --json
+  geo feedback delete --id "feedback-id"
+  geo feedback promote --id "feedback-id"
+`);
+}