geowiki-cli 1.0.1

package/cli/commands/stats.js

@@ -0,0 +1,90 @@
+/**
+ * Dashboard statistics commands
+ * Usage: geo stats [metrics] [options]
+ */
+
+import { hasFlag } from '../utils/args.js';
+import { apiGet } from '../utils/api.js';
+import { outputJson } from '../utils/output.js';
+
+export async function stats(args) {
+  if (args.includes('--help') || args.includes('-h')) {
+    printStatsHelp();
+    return;
+  }
+
+  const [action, ...subArgs] = args;
+
+  if (action === 'metrics') {
+    await metrics(subArgs);
+    return;
+  }
+
+  if (action && action !== '--json') {
+    console.error(`Unknown action: ${action}. Use 'geo stats --help' for usage.`);
+    process.exit(1);
+  }
+
+  // Default: show dashboard stats (geo stats)
+  const json = hasFlag(args, '--json');
+
+  const data = await apiGet('/api/v1/admin/stats');
+  const statsData = data.data || {};
+
+  if (outputJson(statsData, json)) return;
+
+  console.log('\n=== Dashboard Statistics ===\n');
+  if (statsData.documents !== undefined) console.log(`  Documents: ${statsData.documents}`);
+  if (statsData.categories !== undefined) console.log(`  Categories: ${statsData.categories}`);
+  if (statsData.tags !== undefined) console.log(`  Tags: ${statsData.tags}`);
+  if (statsData.feedback !== undefined) console.log(`  Feedback: ${statsData.feedback}`);
+  if (Array.isArray(statsData.recentDocs) && statsData.recentDocs.length > 0) {
+    console.log(`  Recent Documents (7d): ${statsData.recentDocs.length}`);
+    for (const doc of statsData.recentDocs) {
+      console.log(`    - ${doc.title || doc.slug} (${doc.category || ""})`);
+    }
+  }
+  console.log('');
+}
+
+async function metrics(args) {
+  if (args.includes('--help') || args.includes('-h')) {
+    console.log(`
+Usage: geo stats metrics [options]
+
+Display system metrics (detailed statistics).
+
+Options:
+  --json    Output as JSON
+  --help    Show this help`);
+    return;
+  }
+
+  const json = hasFlag(args, '--json');
+
+  const data = await apiGet('/api/v1/admin/metrics');
+  const metricsData = data.data || {};
+
+  if (outputJson(metricsData, json)) return;
+
+  console.log('\n=== System Metrics ===\n');
+  console.log(JSON.stringify(metricsData, null, 2));
+  console.log('');
+}
+
+function printStatsHelp() {
+  console.log(`
+Usage: geo stats [action] [options]
+
+Actions:
+  metrics   Display detailed system metrics
+
+Options:
+  --json    Output as JSON
+  --help    Show this help
+
+Examples:
+  geo stats                Show dashboard statistics
+  geo stats metrics        Show detailed system metrics
+  geo stats --json         Output as JSON`);
+}

package/cli/commands/tag.js

@@ -0,0 +1,131 @@
+/**
+ * Tag management commands
+ * Usage: geo tag [list|create|update|delete] [options]
+ */
+
+import { extractArg, hasFlag } from '../utils/args.js';
+import { apiGet, apiPost, apiPut, apiDelete } from '../utils/api.js';
+import { outputJson, outputSuccess, confirmDelete } from '../utils/output.js';
+import { dispatch } from '../utils/dispatch.js';
+
+export async function tag(args) {
+  const result = dispatch(args, actions, ['list', 'create', 'update', 'delete'], printTagHelp);
+  if (result) await actions[result.action](result.subArgs);
+}
+
+const actions = {
+  async list(args) {
+    const json = hasFlag(args, '--json');
+    const lang = extractArg(args, '--lang') || extractArg(args, '-l') || 'zh';
+
+    let url = '/api/v1/admin/tags';
+    if (lang) url += `?lang=${lang}`;
+
+    const data = await apiGet(url);
+    const tags = data.data || [];
+
+    if (outputJson(tags, json)) return;
+
+    console.log(`\nTags (${tags.length} found):\n`);
+    tags.forEach(t => {
+      const displayName = lang === 'en' ? (t.name_en || t.name) :
+                          lang === 'jp' ? (t.name_jp || t.name) : t.name;
+      console.log(`  ${t.slug.padEnd(30)} | ${displayName}`);
+      if (t.name_en || t.name_jp) {
+        console.log(`  ${''.padEnd(30)} | EN: ${t.name_en || '-'} | JP: ${t.name_jp || '-'}`);
+      }
+    });
+  },
+
+  async create(args) {
+    const name = extractArg(args, '--name') || extractArg(args, '-n');
+    const slug = extractArg(args, '--slug') || extractArg(args, '-s');
+    const nameEn = extractArg(args, '--name-en');
+    const nameJp = extractArg(args, '--name-jp');
+    const json = hasFlag(args, '--json');
+
+    if (!name || !slug) {
+      console.error('Error: --name and --slug are required');
+      process.exit(1);
+    }
+
+    const payload = { name, slug };
+    if (nameEn) payload.name_en = nameEn;
+    if (nameJp) payload.name_jp = nameJp;
+
+    await apiPost('/api/v1/admin/tags', payload);
+    outputSuccess(`Tag created: ${name} (${slug})`, json, { slug, name, name_en: nameEn, name_jp: nameJp });
+  },
+
+  async update(args) {
+    const slug = extractArg(args, '--slug') || extractArg(args, '-s');
+    const name = extractArg(args, '--name') || extractArg(args, '-n');
+    const nameEn = extractArg(args, '--name-en');
+    const nameJp = extractArg(args, '--name-jp');
+    const json = hasFlag(args, '--json');
+
+    if (!slug) {
+      console.error('Error: --slug is required');
+      process.exit(1);
+    }
+
+    if (!name && !nameEn && !nameJp) {
+      console.error('Error: at least one of --name, --name-en, or --name-jp is required');
+      process.exit(1);
+    }
+
+    const payload = {};
+    if (name) payload.name = name;
+    if (nameEn) payload.name_en = nameEn;
+    if (nameJp) payload.name_jp = nameJp;
+
+    await apiPut(`/api/v1/admin/tags/${encodeURIComponent(slug)}`, payload);
+    outputSuccess(`Tag updated: ${slug}`, json, { slug, ...payload });
+  },
+
+  async delete(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 confirmed = await confirmDelete(`Delete tag "${slug}"?`, args);
+    if (!confirmed) {
+      console.log('Cancelled.');
+      return;
+    }
+
+    await apiDelete(`/api/v1/admin/tags/${encodeURIComponent(slug)}`);
+    outputSuccess(`Tag deleted: ${slug}`, json, { deleted: slug });
+  }
+};
+
+function printTagHelp() {
+  console.log(`
+Usage: geo tag <action> [options]
+
+Actions:
+  list       List all tags
+  create     Create a new tag
+  update     Update tag names (multi-language)
+  delete     Delete a tag
+
+Options:
+  --slug,-s          Tag slug (kebab-case)
+  --name,-n          Display name (Chinese)
+  --name-en          English name
+  --name-jp          Japanese name
+  --lang,-l          Language for list display (zh/en/jp)
+  --json             Machine-readable JSON output
+
+Examples:
+  geo tag list --json
+  geo tag list --lang en
+  geo tag create --name "CAN Bus" --slug can-bus --name-en "CAN Bus" --name-jp "CANバス"
+  geo tag update --slug can-bus --name "CAN 总线" --name-en "CAN Bus" --name-jp "CANバス"
+  geo tag delete --slug can-bus
+`);
+}

package/cli/commands/user.js

@@ -0,0 +1,195 @@
+/**
+ * User management commands
+ * Usage: geo user [list|create|update|delete|reset-password] [options]
+ */
+
+import { extractArg, hasFlag } from '../utils/args.js';
+import { apiGet, apiPost, apiPut, apiDelete } from '../utils/api.js';
+import { outputJson, outputSuccess, confirmDelete } from '../utils/output.js';
+import { dispatch } from '../utils/dispatch.js';
+
+export async function user(args) {
+  const result = dispatch(args, actions, ['list', 'create', 'update', 'delete', 'reset-password', 'token'], printUserHelp);
+  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/users');
+    const users = data.data || [];
+
+    if (outputJson(users, json)) return;
+
+    console.log(`\nUsers (${users.length} found):\n`);
+    users.forEach(u => {
+      console.log(`  ${(u.username || '').padEnd(20)} | role=${(u.role || '').padEnd(10)} | id=${u.id || u._id || ''}`);
+    });
+    console.log('\nTip: Use --username to lookup user (e.g. geo user delete --username "editor1")');
+  },
+
+  /**
+   * Resolve --id from --username if needed (looks up user list)
+   */
+  async resolveId(args) {
+    let id = extractArg(args, '--id');
+    if (id) return id;
+
+    const username = extractArg(args, '--username');
+    if (!username) return null;
+
+    // Look up user by username
+    const data = await apiGet('/api/v1/admin/users');
+    const users = data.data || [];
+    const user = users.find(u => u.username === username);
+    if (user) return user.id || user._id;
+    console.error(`Error: user "${username}" not found`);
+    process.exit(1);
+  },
+
+  async create(args) {
+    const username = extractArg(args, '--username');
+    const password = extractArg(args, '--password');
+    const role = extractArg(args, '--role') || 'editor';
+    const json = hasFlag(args, '--json');
+
+    if (!username || !password) {
+      console.error('Error: --username and --password are required');
+      process.exit(1);
+    }
+
+    const data = await apiPost('/api/v1/admin/users', { username, password, role });
+    const user = data.data || {};
+    outputSuccess(`User created: ${username} (role: ${role})`, json, { username, role, id: user.id || user._id });
+  },
+
+  async update(args) {
+    const id = await actions.resolveId(args);
+    const role = extractArg(args, '--role');
+    const newUsername = extractArg(args, '--new-username');
+    const json = hasFlag(args, '--json');
+
+    if (!id) {
+      console.error('Error: --id or --username is required');
+      process.exit(1);
+    }
+
+    const payload = {};
+    if (role != null) payload.role = role; // extractArg returns null when not found
+    if (newUsername != null) payload.username = newUsername;
+
+    if (Object.keys(payload).length === 0) {
+      console.error('Error: nothing to update (use --role or --username)');
+      process.exit(1);
+    }
+
+    await apiPut(`/api/v1/admin/users/${encodeURIComponent(id)}`, payload);
+    outputSuccess(`User updated: ${id}`, json, { id, ...payload });
+  },
+
+  async delete(args) {
+    const id = await actions.resolveId(args);
+    const json = hasFlag(args, '--json');
+
+    if (!id) {
+      console.error('Error: --id or --username is required');
+      process.exit(1);
+    }
+
+    const confirmed = await confirmDelete(`Delete user "${id}"?`, args);
+    if (!confirmed) {
+      console.log('Cancelled.');
+      return;
+    }
+
+    await apiDelete(`/api/v1/admin/users/${encodeURIComponent(id)}`);
+    outputSuccess(`User deleted: ${id}`, json, { deleted: id });
+  },
+
+  async 'reset-password'(args) {
+    const id = await actions.resolveId(args);
+    const json = hasFlag(args, '--json');
+
+    if (!id) {
+      console.error('Error: --id or --username is required');
+      process.exit(1);
+    }
+
+    const data = await apiPost(`/api/v1/admin/users/${encodeURIComponent(id)}/reset-password`);
+    const result = data.data || {};
+    const newPassword = result.password || result.newPassword;
+    if (newPassword) {
+      outputSuccess(`Password reset for user ${id}`, json, { id, newPassword });
+    } else {
+      outputSuccess(`Password reset for user ${id}`, json, { id });
+    }
+  },
+
+  async token(args) {
+    const action = args.find(a => ['list', 'delete'].includes(a));
+    const tokenId = extractArg(args, '--id');
+    const json = hasFlag(args, '--json');
+
+    if (!action) {
+      console.error('Error: token action required (list/delete)');
+      console.error('Token creation is only available in the web admin panel (Settings → API Token).');
+      process.exit(1);
+    }
+
+    if (action === 'list') {
+      const data = await apiGet('/api/v1/auth/tokens');
+      const tokens = data.data || [];
+      if (outputJson(tokens, json)) return;
+      if (tokens.length === 0) {
+        console.log('\nNo API tokens found.\n');
+        return;
+      }
+      console.log(`\nAPI Tokens (${tokens.length}):\n`);
+      tokens.forEach(t => {
+        console.log(`  ${(t.name || '').padEnd(20)} | id=${t.id || ''} | created=${t.createdAt || ''}`);
+      });
+      console.log('');
+    } else if (action === 'delete') {
+      if (!tokenId) {
+        console.error('Error: --id is required');
+        process.exit(1);
+      }
+      await apiDelete(`/api/v1/auth/tokens/${tokenId}`);
+      outputSuccess(`Token ${tokenId} revoked`, json);
+    }
+  }
+};
+
+function printUserHelp() {
+  console.log(`
+Usage: geo user <action> [options]
+
+Actions:
+  list            List all users
+  create          Create a new user
+  update          Update user role or username
+  delete          Delete a user
+  reset-password  Reset a user's password
+  token           Manage API tokens (list/delete, create via web UI only)
+
+Options:
+  --id              User ID (for update/delete/reset-password)
+  --username        Username (for create; or lookup ID for update/delete/reset-password)
+  --new-username    New username (for update only)
+  --password        Password (required for create)
+  --role            User role: admin, editor, viewer (default: editor)
+  --yes, -y         Skip confirmation prompt (for delete)
+  --json            Machine-readable JSON output
+
+Examples:
+  geo user list --json
+  geo user create --username "editor1" --password "Pass123" --role editor
+  geo user update --username "editor1" --role admin
+  geo user update --username "editor1" --new-username "editor2"
+  geo user delete --username "editor1" --yes
+  geo user reset-password --username "editor1"
+  geo user token list --json
+  geo user token delete --id "token-id" --yes`);
+
+}

package/cli/index.js

@@ -0,0 +1,178 @@
+#!/usr/bin/env node
+/**
+ * GEO Wiki CLI - Agent-facing command line tool
+ */
+
+import { readFileSync } from 'fs';
+import { fileURLToPath } from 'url';
+import { dirname, join } from 'path';
+import { login } from './commands/login.js';
+import { doc } from './commands/doc.js';
+import { media } from './commands/media.js';
+import { geo } from './commands/geo.js';
+import { search } from './commands/search.js';
+import { category } from './commands/category.js';
+import { tag } from './commands/tag.js';
+import { config } from './commands/config.js';
+import { user } from './commands/user.js';
+import { draft } from './commands/draft.js';
+import { stats } from './commands/stats.js';
+import { feedback } from './commands/feedback.js';
+import { guestbook } from './commands/guestbook.js';
+import { config as appConfig } from './utils/config.js';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const pkg = JSON.parse(readFileSync(join(__dirname, '..', 'package.json'), 'utf-8'));
+
+const commands = { login, doc, media, geo, search, category, tag, config, user, draft, stats, feedback, guestbook };
+
+function isHelpFlag(args) {
+  return args.includes('--help') || args.includes('-h');
+}
+
+async function main() {
+  const args = process.argv.slice(2);
+
+  // Handle --version flag
+  if (args.includes('--version') || args.includes('-v')) {
+    console.log(`geowiki-cli v${pkg.version}`);
+    return;
+  }
+
+  if (args.length === 0 || (args.length === 1 && isHelpFlag(args))) {
+    printHelp();
+    return;
+  }
+
+  const [cmd, ...subArgs] = args;
+
+  if (cmd === 'login') {
+    await login(subArgs);
+    return;
+  }
+
+  if (cmd === 'logout') {
+    appConfig.clearToken();
+    console.log('Logged out successfully.');
+    return;
+  }
+
+  if (cmd === 'status') {
+    await status();
+    return;
+  }
+
+  const token = appConfig.getToken();
+  if (!token && !['login'].includes(cmd) && !isHelpFlag(subArgs)) {
+    console.error('Not logged in. Run: geo login --url URL --user USER --pass PASS');
+    process.exit(1);
+  }
+
+  if (commands[cmd]) {
+    await commands[cmd](subArgs);
+  } else {
+    console.error(`Unknown command: ${cmd}`);
+    printHelp();
+    process.exit(1);
+  }
+}
+
+function printHelp() {
+  console.log(`
+GEO Wiki CLI - AI Agent Wiki Management Tool
+
+Usage:
+  geo <command> [options]
+
+Commands:
+  login          Authenticate and save session
+  logout         Clear stored credentials
+  status         Show current connection status
+  doc            Document operations (create/list/get/update/delete/reorder)
+  category       Category management (list/create/update/reorder/delete)
+  tag            Tag management (list/create/delete)
+  config         Site configuration (get/update)
+  user           User management (list/create/update/delete/reset-password)
+  draft          Draft management (list/get/publish/delete)
+  stats          Dashboard statistics and metrics
+  feedback       Feedback management (list/delete/promote)
+  guestbook      Guestbook management (list/toggle/update/delete)
+  media          Media operations (upload/list/delete)
+  geo            GEO status, manifest, and report
+  search         Search documents
+
+All commands support --json flag for structured agent output.
+
+Examples:
+  geo login --url http://your-site:9002 --user <username> --pass <password>
+  geo category create --name "CAN MOTION" --slug can-motion
+  geo category list --json
+  geo doc create --file ./product.md --category can-motion --lang zh
+  geo doc list --category can-motion --json
+  geo doc reorder --orders "slug1:0,slug2:1"
+  geo tag create --name "CAN Bus" --slug can-bus
+  geo config get --json
+  geo user list --json
+  geo draft list --json
+  geo stats --json
+  geo feedback list --json
+  geo guestbook list --json
+  geo geo status
+  geo geo report --json
+  geo search "CAN bus"
+
+For help on specific command:
+  geo <command> --help
+`);
+}
+
+async function status() {
+  const cookie = appConfig.getCookie();
+  const apiToken = appConfig.getApiToken();
+  const baseUrl = appConfig.getBaseUrl();
+
+  if (!cookie && !apiToken) {
+    console.log('Status: Not logged in');
+    return;
+  }
+
+  const authType = apiToken ? 'API Token' : 'httpOnly Cookie (geo_wiki_token)';
+  console.log(`Status: Logged in`);
+  console.log(`Base URL: ${baseUrl || 'Not set'}`);
+  console.log(`Auth: ${authType}`);
+
+  if (!baseUrl) {
+    console.log('Connection: Unknown (base URL not set)');
+    return;
+  }
+
+  try {
+    // Build headers based on auth type
+    const headers = {};
+    if (apiToken) {
+      headers['Authorization'] = `Bearer ${apiToken}`;
+    } else {
+      headers['Cookie'] = cookie;
+    }
+
+    const res = await fetch(`${baseUrl}/api/v1/auth/me`, { headers });
+    if (res.ok) {
+      const data = await res.json().catch(() => ({}));
+      const user = data?.data?.user;
+      if (user) {
+        console.log(`Connection: OK (user: ${user.username}, role: ${user.role})`);
+      } else {
+        console.log('Connection: OK');
+      }
+    } else if (res.status === 401) {
+      console.log('Connection: Session expired (please run `geo login` again)');
+    } else {
+      console.log(`Connection: Failed (HTTP ${res.status})`);
+    }
+  } catch (e) {
+    console.log(`Connection: Error - ${e.message}`);
+  }
+}
+
+export { main };
+export default main;

package/cli/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "geowiki-cli",
+  "version": "3.0.49",
+  "description": "GEO Wiki CLI - AI-powered knowledge base management tool",
+  "type": "module",
+  "main": "cli/index.js",
+  "bin": {
+    "geo": "../bin/geo.js"
+  },
+  "files": [
+    "bin/",
+    "cli/",
+    "!cli/__tests__/"
+  ],
+  "scripts": {
+    "test": "vitest run"
+  },
+  "dependencies": {
+    "gray-matter": "^4.0.3"
+  },
+  "devDependencies": {
+    "vitest": "^1.2.0"
+  },
+  "keywords": [
+    "geo",
+    "wiki",
+    "knowledge-base",
+    "cli",
+    "ai",
+    "seo"
+  ],
+  "author": "GEO Wiki Team",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/ai-littleyao/geo-wiki-framework.git"
+  },
+  "engines": {
+    "node": ">=18"
+  }
+}