npm - docs-i18n - Versions diffs - 0.1.0 → 0.2.1 - Mend

docs-i18n 0.1.0 → 0.2.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (49) hide show

package/dist/{assemble-IOHQYYHI.js → assemble-ZHDLGVTL.js} +3 -4
package/dist/chunk-I74LIORX.js +11211 -0
package/dist/{chunk-QSVWLTGQ.js → chunk-OSMPWXSQ.js} +1 -1
package/dist/{chunk-AKLW2MUS.js → chunk-PHDMD6EM.js} +29 -7
package/dist/cli.js +6 -7
package/dist/{rescan-VB2PILB2.js → rescan-OJTVWDAP.js} +2 -3
package/dist/server-HNVJP43X.js +2742 -0
package/dist/{status-EWQEACVF.js → status-ZG7F3FRT.js} +1 -2
package/dist/translate-2PCYIWIG.js +14531 -0
package/package.json +3 -2
package/src/admin/index.html +13 -0
package/src/admin/server/index.ts +88 -0
package/src/admin/server/routes/jobs.ts +113 -0
package/src/admin/server/routes/models.ts +87 -0
package/src/admin/server/routes/status.ts +57 -0
package/src/admin/server/services/job-manager.ts +184 -0
package/src/admin/server/services/status.ts +183 -0
package/src/admin/ui/App.tsx +326 -0
package/src/admin/ui/components/FileList.tsx +438 -0
package/src/admin/ui/components/JobDialog.tsx +360 -0
package/src/admin/ui/components/JobPanel.tsx +134 -0
package/src/admin/ui/components/LangGrid.tsx +54 -0
package/src/admin/ui/components/Preview.tsx +369 -0
package/src/admin/ui/components/ProgressBar.tsx +21 -0
package/src/admin/ui/lib/api.ts +154 -0
package/src/admin/ui/lib/flags.ts +30 -0
package/src/admin/ui/main.tsx +19 -0
package/src/admin/ui/styles.css +1096 -0
package/src/admin/vite.config.ts +7 -0
package/dist/build-4EQEL4NI.js +0 -12
package/dist/build2-3W5WMFHZ.js +0 -4901
package/dist/chunk-3YNFMSJH.js +0 -30
package/dist/chunk-55MBYBVK.js +0 -368
package/dist/chunk-FYDB7MZX.js +0 -38944
package/dist/chunk-O35QHRY6.js +0 -6
package/dist/chunk-PTIH4GGE.js +0 -44
package/dist/chunk-SUIDX6IZ.js +0 -122
package/dist/chunk-VKKNQBDN.js +0 -6487
package/dist/dist-6C32URTL.js +0 -19
package/dist/dist-HOWMMQFV.js +0 -6677
package/dist/false-JGP4AGWN.js +0 -7
package/dist/main-QVE5TVA3.js +0 -2505
package/dist/node-4GLCLDJ6.js +0 -875
package/dist/node-NUDVMOF2.js +0 -129
package/dist/postcss-3SK7VUC2.js +0 -5886
package/dist/postcss-import-JD46KA2Z.js +0 -458
package/dist/prompt-BYQIwEjg-TG7DLENB.js +0 -915
package/dist/server-ER56DGPR.js +0 -548
package/dist/translate-F3AQFN6X.js +0 -707

package/package.json CHANGED Viewed

@@ -1,7 +1,7 @@
 {
   "name": "docs-i18n",
-  "version": "0.1.0",
-  "description": "Universal documentation translation engine \u2014 parse, translate, cache, assemble, manage.",
+  "version": "0.2.1",
+  "description": "Universal documentation translation engine — parse, translate, cache, assemble, manage.",
   "type": "module",
   "bin": {
     "docs-i18n": "dist/cli.js"
@@ -14,6 +14,7 @@
   },
   "files": [
     "dist",
+    "src/admin",
     "README.md"
   ],
   "scripts": {

package/src/admin/index.html ADDED Viewed

@@ -0,0 +1,13 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1">
+  <title>Translation Admin</title>
+</head>
+<body>
+  <script>document.documentElement.dataset.theme=localStorage.getItem('theme')||'dark'</script>
+  <div id="root"></div>
+  <script type="module" src="/ui/main.tsx"></script>
+</body>
+</html>

package/src/admin/server/index.ts ADDED Viewed

@@ -0,0 +1,88 @@
+import { createServer } from 'node:http';
+import { resolve } from 'node:path';
+import { Hono } from 'hono';
+import type { DocsI18nConfig } from '../../config';
+import { initStatus } from './services/status';
+import jobRoutes from './routes/jobs';
+import modelRoutes from './routes/models';
+import statusRoutes from './routes/status';
+export async function startAdmin(config: DocsI18nConfig, port = 3456) {
+  initStatus(config);
+  const app = new Hono();
+  app.route('/api/status', statusRoutes);
+  app.route('/api/jobs', jobRoutes);
+  app.route('/api/models', modelRoutes);
+  app.get('/api/health', (c) => c.json({ ok: true }));
+  app.get('/api/config', (c) => c.json({ projectRoot: process.cwd() }));
+  // Open file in editor
+  app.post('/api/open-file', async (c) => {
+    const { file } = await c.req.json<{ file: string }>();
+    if (!file) return c.json({ error: 'Missing file' }, 400);
+    const fullPath = resolve(process.cwd(), file);
+    if (!fullPath.startsWith(process.cwd())) return c.json({ error: 'Invalid path' }, 400);
+    const candidates = process.env.EDITOR_CMD ? [process.env.EDITOR_CMD] : ['code', 'cursor', 'zed'];
+    for (const cmd of candidates) {
+      const which = Bun.spawn(['which', cmd], { stdio: ['ignore', 'pipe', 'ignore'] });
+      await which.exited;
+      if (which.exitCode === 0) {
+        Bun.spawn([cmd, fullPath], { stdio: ['ignore', 'ignore', 'ignore'] });
+        return c.json({ opened: fullPath, editor: cmd });
+      }
+    }
+    const fallback = process.platform === 'darwin' ? 'open' : process.platform === 'win32' ? 'start' : 'xdg-open';
+    Bun.spawn([fallback, fullPath], { stdio: ['ignore', 'ignore', 'ignore'] });
+    return c.json({ opened: fullPath, editor: fallback });
+  });
+  const adminRoot = resolve(import.meta.dir, '..');
+  // Try to load Vite for dev mode (SPA)
+  try {
+    const { createServer: createViteServer } = await import('vite');
+    const vite = await createViteServer({
+      root: adminRoot,
+      server: { middlewareMode: true },
+      appType: 'spa',
+    });
+    const server = createServer(async (req, res) => {
+      const url = req.url ?? '/';
+      if (url.startsWith('/api')) {
+        const headers = new Headers();
+        for (const [k, v] of Object.entries(req.headers)) {
+          if (v) headers.set(k, Array.isArray(v) ? v.join(', ') : v);
+        }
+        const body = req.method !== 'GET' && req.method !== 'HEAD'
+          ? await new Promise<string>((r) => {
+              let data = '';
+              req.on('data', (c: Buffer) => { data += c.toString(); });
+              req.on('end', () => r(data));
+            })
+          : undefined;
+        const webReq = new Request(`http://localhost:${port}${url}`, {
+          method: req.method,
+          headers,
+          body,
+        });
+        const webRes = await app.fetch(webReq);
+        res.writeHead(webRes.status, Object.fromEntries(webRes.headers.entries()));
+        res.end(Buffer.from(await webRes.arrayBuffer()));
+        return;
+      }
+      vite.middlewares(req, res);
+    });
+    server.listen(port, () => {
+      console.log(`🌐 docs-i18n admin → http://localhost:${port}`);
+    });
+  } catch {
+    console.error('Failed to start admin UI (vite not available). API-only mode.');
+    // Fallback: just run Hono without Vite
+    const server = Bun.serve({ port, fetch: app.fetch });
+    console.log(`🌐 docs-i18n admin (API only) → http://localhost:${port}`);
+  }
+}

package/src/admin/server/routes/jobs.ts ADDED Viewed

@@ -0,0 +1,113 @@
+import { Hono } from 'hono';
+import { streamSSE } from 'hono/streaming';
+import { jobManager } from '../services/job-manager';
+const app = new Hono();
+/** GET /api/jobs — List all jobs */
+app.get('/', (c) => {
+  return c.json(
+    jobManager.list().map((j) => ({
+      ...j,
+      logLines: (j.logLines ?? []).slice(-20), // Last 20 lines in list view
+    })),
+  );
+});
+/** POST /api/jobs — Start a new translation job */
+app.post('/', async (c) => {
+  const body = await c.req.json<{
+    lang: string;
+    version: string;
+    max?: number;
+    concurrency?: number;
+    model?: string;
+    modelRotate?: string[];
+    md5?: boolean;
+    files?: string[];
+  }>();
+  if (!body.lang || !body.version) {
+    return c.json({ error: 'Missing lang or version' }, 400);
+  }
+  try {
+    const job = jobManager.start(body);
+    return c.json(job, 201);
+  } catch (err) {
+    return c.json(
+      { error: err instanceof Error ? err.message : 'Unknown error' },
+      409,
+    );
+  }
+});
+/** GET /api/jobs/:id — Get job details */
+app.get('/:id', (c) => {
+  const job = jobManager.get(c.req.param('id'));
+  if (!job) return c.json({ error: 'Job not found' }, 404);
+  return c.json(job);
+});
+/** DELETE /api/jobs/:id — Cancel a running job or remove a finished one */
+app.delete('/:id', (c) => {
+  const id = c.req.param('id');
+  const job = jobManager.get(id);
+  if (!job) return c.json({ error: 'Job not found' }, 404);
+  if (job.status === 'running') {
+    jobManager.cancel(id);
+  } else {
+    jobManager.remove(id);
+  }
+  return c.json({ ok: true });
+});
+/** GET /api/jobs/:id/stream — SSE stream of job events */
+app.get('/:id/stream', (c) => {
+  const id = c.req.param('id');
+  const job = jobManager.get(id);
+  if (!job) return c.json({ error: 'Job not found' }, 404);
+  return streamSSE(c, async (stream) => {
+    // Send current state
+    await stream.writeSSE({
+      data: JSON.stringify({
+        type: 'state',
+        data: { ...job, logLines: (job.logLines ?? []).slice(-50) },
+      }),
+      event: 'message',
+    });
+    // Subscribe to future events
+    const unsubscribe = jobManager.subscribe(id, async (event) => {
+      try {
+        await stream.writeSSE({
+          data: JSON.stringify(event),
+          event: 'message',
+        });
+      } catch {
+        // Client disconnected
+        unsubscribe();
+      }
+    });
+    // Keep alive until client disconnects or job ends
+    while (true) {
+      const currentJob = jobManager.get(id);
+      if (!currentJob || currentJob.status !== 'running') {
+        // Send final state
+        await stream.writeSSE({
+          data: JSON.stringify({ type: 'done', data: currentJob }),
+          event: 'message',
+        });
+        break;
+      }
+      await stream.sleep(1000);
+    }
+    unsubscribe();
+  });
+});
+export default app;

package/src/admin/server/routes/models.ts ADDED Viewed

@@ -0,0 +1,87 @@
+import { Hono } from 'hono';
+const app = new Hono();
+interface OpenRouterModel {
+  id: string;
+  name: string;
+  pricing: {
+    prompt: string;
+    completion: string;
+  };
+  context_length: number;
+  architecture: {
+    modality: string;
+    output_modalities: string[];
+    tokenizer: string;
+  };
+  top_provider: {
+    context_length: number;
+    max_completion_tokens: number;
+    is_moderated: boolean;
+  };
+  supported_parameters: string[];
+}
+let cachedResult: ReturnType<typeof formatModels> | null = null;
+let cacheTime = 0;
+const CACHE_TTL = 5 * 60 * 1000;
+/** GET /api/models — List OpenRouter models */
+app.get('/', async (c) => {
+  const now = Date.now();
+  if (cachedResult && now - cacheTime < CACHE_TTL) {
+    return c.json(cachedResult);
+  }
+  try {
+    const res = await fetch('https://openrouter.ai/api/v1/models');
+    if (!res.ok) {
+      return c.json({ error: `OpenRouter API error: ${res.status}` }, 502);
+    }
+    const { data } = (await res.json()) as { data: OpenRouterModel[] };
+    cachedResult = formatModels(data);
+    cacheTime = now;
+    return c.json(cachedResult);
+  } catch (err) {
+    return c.json(
+      { error: err instanceof Error ? err.message : 'Failed to fetch models' },
+      500,
+    );
+  }
+});
+function formatModels(models: OpenRouterModel[]) {
+  return models
+    .filter((m) => {
+      if (!m.pricing) return false;
+      const pp = Number.parseFloat(m.pricing.prompt);
+      const cp = Number.parseFloat(m.pricing.completion);
+      if (pp < 0 || cp < 0) return false;
+      // Only text→text models
+      if (!m.architecture?.modality?.startsWith('text')) return false;
+      if (!m.architecture.output_modalities?.includes('text')) return false;
+      return true;
+    })
+    .map((m) => {
+      const pp = Number.parseFloat(m.pricing.prompt) * 1_000_000;
+      const cp = Number.parseFloat(m.pricing.completion) * 1_000_000;
+      return {
+        id: m.id,
+        name: m.name,
+        promptPrice: pp,
+        completionPrice: cp,
+        contextLength: m.context_length,
+        maxOutput: m.top_provider?.max_completion_tokens ?? 0,
+        isFree: pp === 0 && cp === 0,
+        supportsJson:
+          m.supported_parameters?.includes('response_format') ||
+          m.supported_parameters?.includes('structured_outputs'),
+        supportsTools: m.supported_parameters?.includes('tools'),
+        provider: m.id.split('/')[0],
+      };
+    })
+    .sort((a, b) => a.promptPrice - b.promptPrice);
+}
+export default app;

package/src/admin/server/routes/status.ts ADDED Viewed

@@ -0,0 +1,57 @@
+import { Hono } from 'hono';
+import {
+  getCache,
+  getFileBlocks,
+  getFileCoverage,
+  getFileDetail,
+  getLangs,
+  getOverview,
+  getVersions,
+  rescan,
+} from '../services/status';
+const app = new Hono();
+app.get('/', (c) => {
+  return c.json({
+    versions: getVersions(),
+    langs: ['en', ...getLangs()],
+    data: getOverview(),
+  });
+});
+app.get('/:version/:lang', (c) => {
+  const { version, lang } = c.req.param();
+  if (lang === 'en') {
+    const anyLang = getLangs()[0];
+    const coverage = getFileCoverage(version, anyLang);
+    return c.json(coverage.map((f) => ({ file: f.file, total: f.total, translated: f.total })));
+  }
+  return c.json(getFileCoverage(version, lang));
+});
+app.get('/:version/:lang/blocks', (c) => {
+  const { version, lang } = c.req.param();
+  const filePath = c.req.query('path');
+  if (!filePath) return c.json({ error: 'Missing path query param' }, 400);
+  const blocks = getFileBlocks(version, lang, filePath);
+  if (!blocks) return c.json({ error: 'File not found' }, 404);
+  return c.json({ file: filePath, lang, version, blocks });
+});
+app.delete('/:version/:lang/cache', (c) => {
+  const { lang } = c.req.param();
+  const key = c.req.query('key');
+  if (!key) return c.json({ error: 'Missing key query param' }, 400);
+  const cache = getCache();
+  cache.db.prepare('DELETE FROM translations WHERE lang = ? AND key = ?').run(lang, key);
+  return c.json({ deleted: key, lang });
+});
+app.post('/:version/rescan', (c) => {
+  const { version } = c.req.param();
+  const count = rescan(version);
+  return c.json({ version, files: count });
+});
+export default app;

package/src/admin/server/services/job-manager.ts ADDED Viewed

@@ -0,0 +1,184 @@
+import { type ChildProcess, spawn } from 'node:child_process';
+import { resolve } from 'node:path';
+const PROJECT_ROOT = process.cwd();
+export interface Job {
+  id: string;
+  lang: string;
+  version: string;
+  project: string;
+  status: 'running' | 'completed' | 'failed' | 'cancelled';
+  startedAt: string;
+  finishedAt?: string;
+  exitCode?: number | null;
+  logLines?: string[];
+  currentFile?: string;
+  translatedFiles: number;
+  totalFiles: number;
+  toTranslate: number;
+  errorFiles: number;
+}
+interface JobEvent {
+  type: 'log' | 'exit';
+  data?: string;
+  code?: number | null;
+}
+export class JobManager {
+  private jobs = new Map<string, Job>();
+  private processes = new Map<string, ChildProcess>();
+  private subscribers = new Map<string, Set<(event: JobEvent) => void>>();
+  private nextId = 1;
+  start(opts: {
+    lang: string;
+    version: string;
+    project?: string;
+    max?: number;
+    concurrency?: number;
+    model?: string;
+    files?: string[];
+  }): Job {
+    // Prevent duplicate
+    for (const [, job] of this.jobs) {
+      if (job.lang === opts.lang && job.version === opts.version && job.status === 'running') {
+        throw new Error(`Job already running for ${opts.lang}/${opts.version}`);
+      }
+    }
+    const id = `job-${this.nextId++}`;
+    const job: Job = {
+      id,
+      lang: opts.lang,
+      version: opts.version,
+      project: opts.project ?? '',
+      status: 'running',
+      startedAt: new Date().toISOString(),
+      logLines: [],
+      translatedFiles: 0,
+      totalFiles: 0,
+      toTranslate: 0,
+      errorFiles: 0,
+    };
+    this.jobs.set(id, job);
+    // Build CLI args — call docs-i18n translate
+    const args = [
+      'src/cli.ts', // In dev; in production would be the installed bin
+      'translate',
+      '--lang', opts.lang,
+      '--version', opts.version,
+      '--max', String(opts.max ?? 999),
+      '--concurrency', String(opts.concurrency ?? 3),
+    ];
+    if (opts.project) args.push('--project', opts.project);
+    if (opts.model) args.push('--model', opts.model);
+    if (opts.files?.length) args.push('--files', opts.files.join(','));
+    const proc = spawn('bun', args, {
+      cwd: PROJECT_ROOT,
+      stdio: ['ignore', 'pipe', 'pipe'],
+      env: { ...process.env, NO_TTY: '1', FORCE_COLOR: '0' },
+    });
+    this.processes.set(id, proc);
+    proc.stdout?.on('data', (d: Buffer) => {
+      for (const line of d.toString().split('\n').filter(Boolean)) {
+        this.addLog(id, line);
+        this.parseProgress(job, line);
+      }
+    });
+    proc.stderr?.on('data', (d: Buffer) => {
+      for (const line of d.toString().split('\n').filter(Boolean)) {
+        this.addLog(id, line);
+      }
+    });
+    proc.on('exit', (code) => {
+      job.status = code === 0 ? 'completed' : 'failed';
+      job.exitCode = code;
+      job.finishedAt = new Date().toISOString();
+      job.currentFile = undefined;
+      this.addLog(id, `Process exited with code ${code}`);
+      this.processes.delete(id);
+      this.emit(id, { type: 'exit', code });
+    });
+    proc.on('error', (err) => {
+      job.status = 'failed';
+      job.finishedAt = new Date().toISOString();
+      this.addLog(id, `Process error: ${err.message}`);
+      this.processes.delete(id);
+      this.emit(id, { type: 'exit', code: -1 });
+    });
+    return job;
+  }
+  cancel(id: string): boolean {
+    const proc = this.processes.get(id);
+    const job = this.jobs.get(id);
+    if (!proc || !job) return false;
+    proc.kill('SIGTERM');
+    job.status = 'cancelled';
+    job.finishedAt = new Date().toISOString();
+    this.processes.delete(id);
+    this.emit(id, { type: 'exit', code: null });
+    return true;
+  }
+  list(): Job[] {
+    return [...this.jobs.values()].sort(
+      (a, b) => new Date(b.startedAt).getTime() - new Date(a.startedAt).getTime(),
+    );
+  }
+  get(id: string): Job | undefined {
+    return this.jobs.get(id);
+  }
+  remove(id: string): boolean {
+    const job = this.jobs.get(id);
+    if (!job || job.status === 'running') return false;
+    this.jobs.delete(id);
+    this.subscribers.delete(id);
+    return true;
+  }
+  subscribe(id: string, callback: (event: JobEvent) => void): () => void {
+    if (!this.subscribers.has(id)) this.subscribers.set(id, new Set());
+    this.subscribers.get(id)?.add(callback);
+    return () => { this.subscribers.get(id)?.delete(callback); };
+  }
+  private addLog(id: string, line: string) {
+    const job = this.jobs.get(id);
+    if (!job) return;
+    const ts = new Date().toLocaleTimeString('en-US', { hour12: false });
+    const entry = `[${ts}] ${line}`;
+    job.logLines = job.logLines ?? [];
+    job.logLines.push(entry);
+    if (job.logLines.length > 500) job.logLines.shift();
+    this.emit(id, { type: 'log', data: entry });
+  }
+  private emit(id: string, event: JobEvent) {
+    this.subscribers.get(id)?.forEach((cb) => cb(event));
+  }
+  private parseProgress(job: Job, line: string) {
+    const cached = line.match(/\+(\d+) cached/);
+    if (cached) job.translatedFiles += Number.parseInt(cached[1], 10);
+    const untranslated = line.match(/(\d+) untranslated keys/);
+    if (untranslated) job.toTranslate = Number.parseInt(untranslated[1], 10);
+    const chunk = line.match(/chunk \d+\/(\d+)/);
+    if (chunk) job.totalFiles = Number.parseInt(chunk[1], 10);
+    if (line.includes('⏳')) job.currentFile = line.replace(/^⏳\s*/, '');
+  }
+}
+export const jobManager = new JobManager();