@seqyuan/annodex 0.1.10 → 0.1.12

package/app/api/models/route.ts

@@ -0,0 +1,67 @@
+/**
+ * Models API — merged list from annodex providers.json + codex config.toml
+ */
+
+import { readMergedConfig, listAllModels, getDefaultModel } from "@/lib/annodex-config";
+
+export const dynamic = "force-dynamic";
+
+const DEFAULT_THINKING_LEVEL_MAP: Record<string, string | null> = {
+  auto: null,
+  off: "off",
+  minimal: "minimal",
+  low: "low",
+  medium: "medium",
+  high: "high",
+  xhigh: "xhigh",
+};
+
+export async function GET() {
+  try {
+    const config = readMergedConfig();
+    const modelOptions = listAllModels(config);
+    const defaultModel = getDefaultModel(config);
+
+    const models: Record<string, string> = {};
+    const modelList: { id: string; name: string; provider: string; contextWindow?: number; maxTokens?: number; input?: string[] }[] = [];
+    for (const m of modelOptions) {
+      const key = `${m.provider}:${m.modelId}`;
+      models[key] = m.name;
+      modelList.push({
+        id: m.modelId,
+        name: m.name,
+        provider: m.provider,
+        contextWindow: m.contextWindow,
+        maxTokens: m.maxTokens,
+        input: m.input,
+      });
+    }
+
+    const thinkingLevels: Record<string, string[]> = {};
+    const thinkingLevelMaps: Record<string, Record<string, string | null>> = {};
+    for (const m of modelOptions) {
+      const key = `${m.provider}:${m.modelId}`;
+      const levelMap = m.thinkingLevelMap ?? DEFAULT_THINKING_LEVEL_MAP;
+      thinkingLevels[key] = Object.entries(levelMap)
+        .filter(([level, mapped]) => level !== "auto" && mapped !== null)
+        .map(([level]) => level);
+      thinkingLevelMaps[key] = levelMap;
+    }
+
+    return Response.json({
+      models,
+      modelList,
+      defaultModel,
+      thinkingLevels,
+      thinkingLevelMaps,
+    });
+  } catch {
+    return Response.json({
+      models: {},
+      modelList: [],
+      defaultModel: null,
+      thinkingLevels: {},
+      thinkingLevelMaps: {},
+    });
+  }
+}

package/app/api/models-config/discover/route.ts

@@ -0,0 +1,42 @@
+import { NextRequest, NextResponse } from "next/server";
+import { convertToPiModels, enrichModelsWithRemoteMetadata, fetchModelsFromBaseUrl, normalizeBaseUrl } from "@/lib/model-discovery";
+
+export const dynamic = "force-dynamic";
+
+function errorMessage(error: unknown): string {
+  return error instanceof Error ? error.message : String(error);
+}
+
+export async function POST(req: NextRequest) {
+  try {
+    const body = await req.json() as {
+      baseUrl?: unknown;
+      apiKey?: unknown;
+      provider?: unknown;
+      enrich?: unknown;
+    };
+
+    const baseUrl = typeof body.baseUrl === "string" ? normalizeBaseUrl(body.baseUrl) : "";
+    const apiKey = typeof body.apiKey === "string" ? body.apiKey : "";
+    const provider = typeof body.provider === "string" ? body.provider.trim() : "";
+    if (!baseUrl) {
+      return NextResponse.json({ ok: false, error: "Base URL is required" }, { status: 400 });
+    }
+
+    const fetched = await fetchModelsFromBaseUrl(baseUrl, apiKey);
+    const enriched = body.enrich === false
+      ? fetched.models
+      : await enrichModelsWithRemoteMetadata(baseUrl, apiKey, fetched.models);
+    const piModels = convertToPiModels(enriched, false, provider || undefined, baseUrl);
+
+    return NextResponse.json({
+      ok: true,
+      endpoint: fetched.endpoint,
+      baseUrl,
+      models: enriched,
+      piModels,
+    });
+  } catch (error) {
+    return NextResponse.json({ ok: false, error: errorMessage(error) }, { status: 500 });
+  }
+}

package/app/api/models-config/route.ts

@@ -0,0 +1,152 @@
+/**
+ * Models Config API — reads/writes ~/.config/annodex/providers.json
+ *
+ * Annodex maintains its own provider list with API keys.
+ * Codex config.toml providers are merged read-only at runtime.
+ */
+
+import { NextResponse } from "next/server";
+import {
+  readMergedConfig,
+  readProvidersFile as readProviders,
+  writeProvidersFile as writeProviders,
+} from "@/lib/annodex-config";
+import { isProviderApi, normalizeProviderApi } from "@/lib/provider-api";
+
+export const dynamic = "force-dynamic";
+
+type ModelConfigBody = {
+  id: string;
+  name?: string;
+  api?: string;
+  reasoning?: boolean;
+  thinkingLevelMap?: Record<string, string | null>;
+  input?: string[];
+  contextWindow?: number;
+  maxTokens?: number;
+  compat?: Record<string, unknown>;
+};
+
+type ProviderConfigBody = {
+  baseUrl?: string;
+  api?: string;
+  apiKey?: string;
+  requiresOpenAiAuth?: boolean;
+  source?: string;
+  models?: ModelConfigBody[];
+};
+
+function normalizeStringArray(value: unknown): string[] | undefined {
+  if (!Array.isArray(value)) return undefined;
+  const strings = value.filter((item): item is string => typeof item === "string" && item.trim().length > 0);
+  return strings.length ? strings : undefined;
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+function normalizeThinkingLevelMap(value: unknown): Record<string, string | null> | undefined {
+  if (!isRecord(value)) return undefined;
+  const normalized: Record<string, string | null> = {};
+  for (const [key, entry] of Object.entries(value)) {
+    if (typeof entry === "string" || entry === null) normalized[key] = entry;
+  }
+  return Object.keys(normalized).length ? normalized : undefined;
+}
+
+function normalizeCompat(value: unknown): Record<string, unknown> | undefined {
+  if (!isRecord(value)) return undefined;
+  return Object.keys(value).length ? value : undefined;
+}
+
+export async function GET() {
+  try {
+    const data = readMergedConfig();
+    // Return in format compatible with ModelsConfig UI
+    return NextResponse.json({
+      providers: Object.fromEntries(
+        data.providers.map((p) => [
+          p.id,
+          {
+            baseUrl: p.baseUrl,
+            apiKey: p.apiKey,
+            api: p.api ?? "openai-responses",
+            requiresOpenAiAuth: p.requiresOpenAiAuth,
+            source: p.source ?? "annodex",
+            sourceProviderId: p.sourceProviderId,
+            models: p.models.map((m) => ({
+              id: m.id,
+              name: m.name,
+              api: m.api,
+              reasoning: m.reasoning,
+              thinkingLevelMap: m.thinkingLevelMap,
+              input: m.input,
+              contextWindow: m.contextWindow,
+              maxTokens: m.maxTokens,
+              compat: m.compat,
+            })),
+          },
+        ])
+      ),
+      defaultProvider: data.defaultProvider,
+      defaultModel: data.defaultModel,
+    });
+  } catch (error) {
+    return NextResponse.json({ providers: {}, error: String(error) }, { status: 500 });
+  }
+}
+
+export async function PUT(req: Request) {
+  try {
+    const body = await req.json() as {
+      providers?: Record<string, ProviderConfigBody>;
+      defaultProvider?: string;
+      defaultModel?: string;
+    };
+
+    const data = readProviders();
+
+    if (body.providers) {
+      data.providers = Object.entries(body.providers)
+        .filter(([, p]) => typeof p.baseUrl === "string" && p.source !== "codex")
+        .map(([id, p]) => {
+          const baseUrl = (p.baseUrl ?? "").replace(/\/+$/, "");
+          return {
+            id,
+            name: id,
+            baseUrl,
+            api: normalizeProviderApi(p.api, baseUrl, id),
+            apiKey: typeof p.apiKey === "string" ? p.apiKey : "",
+            requiresOpenAiAuth: typeof p.requiresOpenAiAuth === "boolean" ? p.requiresOpenAiAuth : undefined,
+            models: Array.isArray(p.models)
+              ? p.models
+                  .filter((m): m is ModelConfigBody => typeof m.id === "string")
+                  .map((m) => {
+                    const modelId = m.id.trim();
+                    return {
+                      id: modelId,
+                      name: m.name || modelId,
+                      api: isProviderApi(m.api) ? m.api : undefined,
+                      reasoning: typeof m.reasoning === "boolean" ? m.reasoning : undefined,
+                      thinkingLevelMap: normalizeThinkingLevelMap(m.thinkingLevelMap),
+                      input: normalizeStringArray(m.input),
+                      contextWindow: typeof m.contextWindow === "number" ? m.contextWindow : undefined,
+                      maxTokens: typeof m.maxTokens === "number" ? m.maxTokens : undefined,
+                      compat: normalizeCompat(m.compat),
+                    };
+                  })
+                  .filter((m) => m.id)
+              : [],
+          };
+        });
+    }
+    delete data.defaultProvider;
+    delete data.defaultModel;
+
+    writeProviders(data);
+    return NextResponse.json({ success: true });
+  } catch (error) {
+    return NextResponse.json({ error: String(error) }, { status: 500 });
+  }
+}

package/app/api/models-config/test/route.ts

@@ -0,0 +1,154 @@
+/**
+ * Model test route — validates the saved protocol against the provider endpoint.
+ */
+
+import { execSync } from "child_process";
+import { NextResponse } from "next/server";
+import { chatCompletionsUrl } from "@/lib/codex-compat-proxy";
+import { normalizeProviderApi } from "@/lib/provider-api";
+
+export const dynamic = "force-dynamic";
+
+type TestProvider = {
+  baseUrl?: string;
+  api?: string;
+  apiKey?: string;
+};
+
+type TestModel = {
+  id?: string;
+  api?: string;
+};
+
+function resolveApiKey(value?: string): string | undefined {
+  const trimmed = value?.trim();
+  if (!trimmed) return undefined;
+  if (trimmed.startsWith("!")) {
+    try {
+      return execSync(trimmed.slice(1), {
+        encoding: "utf8",
+        stdio: ["ignore", "pipe", "ignore"],
+        timeout: 10_000,
+      }).trim() || undefined;
+    } catch {
+      return undefined;
+    }
+  }
+  if (/^[A-Za-z_][A-Za-z0-9_]*$/.test(trimmed) && process.env[trimmed]) {
+    return process.env[trimmed];
+  }
+  return trimmed;
+}
+
+function endpointFor(baseUrl: string, api: string): string {
+  const normalized = baseUrl.replace(/\/+$/, "");
+  if (api === "openai-completions") {
+    return chatCompletionsUrl(normalized);
+  }
+  return normalized.endsWith("/responses") ? normalized : `${normalized}/responses`;
+}
+
+function buildBody(api: string, modelId: string): Record<string, unknown> {
+  if (api === "openai-completions") {
+    return {
+      model: modelId,
+      messages: [{ role: "user", content: "Reply with pong only." }],
+      max_tokens: 8,
+      stream: false,
+    };
+  }
+  return {
+    model: modelId,
+    input: "Reply with pong only.",
+    max_output_tokens: 8,
+    stream: false,
+  };
+}
+
+function summarizeResponse(payload: unknown): string {
+  if (typeof payload !== "object" || payload === null) return String(payload).slice(0, 200);
+  const record = payload as Record<string, unknown>;
+  const outputText = record.output_text;
+  if (typeof outputText === "string" && outputText) return outputText.slice(0, 200);
+
+  const choices = record.choices;
+  if (Array.isArray(choices) && choices.length > 0) {
+    const first = choices[0] as { message?: { content?: unknown }; text?: unknown };
+    const content = first.message?.content ?? first.text;
+    if (typeof content === "string" && content) return content.slice(0, 200);
+  }
+
+  const error = record.error;
+  if (typeof error === "object" && error !== null && "message" in error) {
+    const message = (error as { message?: unknown }).message;
+    if (typeof message === "string") return message.slice(0, 200);
+  }
+
+  return JSON.stringify(payload).slice(0, 200);
+}
+
+export async function POST(req: Request) {
+  const started = Date.now();
+  try {
+    const body = await req.json() as {
+      providerName?: string;
+      provider?: TestProvider;
+      model?: TestModel;
+    };
+
+    const provider = body.provider ?? {};
+    const modelId = body.model?.id?.trim();
+    const baseUrl = provider.baseUrl?.trim().replace(/\/+$/, "");
+    if (!baseUrl) {
+      return NextResponse.json({ ok: false, error: "Base URL is required" }, { status: 400 });
+    }
+    if (!modelId) {
+      return NextResponse.json({ ok: false, error: "Model ID is required" }, { status: 400 });
+    }
+
+    const api = normalizeProviderApi(body.model?.api ?? provider.api, baseUrl, body.providerName);
+    const apiKey = resolveApiKey(provider.apiKey);
+    const headers: Record<string, string> = { "content-type": "application/json" };
+    if (apiKey) headers.authorization = `Bearer ${apiKey}`;
+
+    const upstream = await fetch(endpointFor(baseUrl, api), {
+      method: "POST",
+      headers,
+      body: JSON.stringify(buildBody(api, modelId)),
+      signal: AbortSignal.timeout(20_000),
+    });
+
+    const text = await upstream.text();
+    let payload: unknown = text;
+    try {
+      payload = JSON.parse(text);
+    } catch {
+      // Plain-text provider errors are still useful for diagnostics.
+    }
+
+    const latencyMs = Date.now() - started;
+    const responseText = summarizeResponse(payload);
+    if (!upstream.ok) {
+      return NextResponse.json({
+        ok: false,
+        error: responseText || `HTTP ${upstream.status}`,
+        latencyMs,
+        status: upstream.status,
+        responseText,
+      }, { status: 502 });
+    }
+
+    return NextResponse.json({
+      ok: true,
+      latencyMs,
+      status: upstream.status,
+      responseText,
+    });
+  } catch (error) {
+    return NextResponse.json({
+      ok: false,
+      error: error instanceof Error ? error.message : String(error),
+      latencyMs: Date.now() - started,
+    }, { status: 500 });
+  }
+}

package/app/api/projects/browse/route.ts

@@ -0,0 +1,51 @@
+import { NextRequest, NextResponse } from "next/server";
+import { readdir, access } from "fs/promises";
+import { constants } from "fs";
+import { homedir } from "os";
+import path from "path";
+
+async function getWindowsDrives(): Promise<string[]> {
+  if (process.platform !== "win32") return [];
+  const drives: string[] = [];
+  for (let code = 65; code <= 90; code += 1) {
+    const drive = `${String.fromCharCode(code)}:\\`;
+    try {
+      await access(drive, constants.R_OK);
+      drives.push(drive);
+    } catch {
+      // drive not available
+    }
+  }
+  return drives;
+}
+
+export async function GET(request: NextRequest) {
+  const dir = request.nextUrl.searchParams.get("dir") || homedir();
+  const resolvedDir = path.resolve(dir);
+
+  try {
+    await access(resolvedDir, constants.R_OK);
+  } catch {
+    return NextResponse.json({ error: "Directory does not exist or cannot be read" }, { status: 404 });
+  }
+
+  try {
+    const entries = await readdir(resolvedDir, { withFileTypes: true });
+    const directories = entries
+      .filter((entry) => entry.isDirectory() && !entry.name.startsWith("."))
+      .map((entry) => ({
+        name: entry.name,
+        path: path.join(resolvedDir, entry.name),
+      }))
+      .sort((a, b) => a.name.localeCompare(b.name));
+
+    return NextResponse.json({
+      current: resolvedDir,
+      parent: path.dirname(resolvedDir) !== resolvedDir ? path.dirname(resolvedDir) : null,
+      directories,
+      drives: await getWindowsDrives(),
+    });
+  } catch {
+    return NextResponse.json({ error: "Cannot read directory" }, { status: 500 });
+  }
+}

package/app/api/projects/route.ts

@@ -0,0 +1,83 @@
+import { NextResponse } from "next/server";
+import { mkdirSync, statSync } from "fs";
+import { listProjects, listProjectsFast, removeProject, renameProject, touchProject, upsertProject } from "@/lib/projects";
+
+function isDirectory(path: string): boolean {
+  try {
+    return statSync(path).isDirectory();
+  } catch {
+    return false;
+  }
+}
+
+export async function GET(req: Request) {
+  try {
+    const url = new URL(req.url);
+    const includeHidden = url.searchParams.get("includeHidden") === "1";
+    const includeSessionStats = url.searchParams.get("sessionStats") === "1";
+    const projects = includeSessionStats
+      ? await listProjects({ includeHidden })
+      : listProjectsFast({ includeHidden });
+    return NextResponse.json({ projects });
+  } catch (error) {
+    return NextResponse.json({ error: String(error) }, { status: 500 });
+  }
+}
+
+export async function POST(req: Request) {
+  try {
+    const body = await req.json() as { cwd?: unknown; name?: unknown; create?: unknown };
+    if (typeof body.cwd !== "string" || !body.cwd.trim()) {
+      return NextResponse.json({ error: "cwd is required" }, { status: 400 });
+    }
+    const cwd = body.cwd.trim();
+    if (body.create === true) {
+      mkdirSync(cwd, { recursive: true });
+    }
+    if (!isDirectory(cwd)) {
+      return NextResponse.json({ error: "Project path must be an existing directory" }, { status: 400 });
+    }
+    const project = upsertProject(cwd, {
+      name: typeof body.name === "string" ? body.name : undefined,
+      hidden: false,
+    });
+    return NextResponse.json({ ok: true, project });
+  } catch (error) {
+    return NextResponse.json({ error: String(error) }, { status: 500 });
+  }
+}
+
+export async function PATCH(req: Request) {
+  try {
+    const body = await req.json() as { cwd?: unknown; name?: unknown; touch?: unknown };
+    if (typeof body.cwd !== "string" || !body.cwd.trim()) {
+      return NextResponse.json({ error: "cwd is required" }, { status: 400 });
+    }
+    if (body.touch === true) {
+      touchProject(body.cwd);
+    } else {
+      if (typeof body.name !== "string") {
+        return NextResponse.json({ error: "name is required" }, { status: 400 });
+      }
+      renameProject(body.cwd, body.name);
+    }
+    const projects = await listProjects();
+    return NextResponse.json({ ok: true, projects });
+  } catch (error) {
+    return NextResponse.json({ error: String(error) }, { status: 500 });
+  }
+}
+
+export async function DELETE(req: Request) {
+  try {
+    const body = await req.json() as { cwd?: unknown };
+    if (typeof body.cwd !== "string" || !body.cwd.trim()) {
+      return NextResponse.json({ error: "cwd is required" }, { status: 400 });
+    }
+    removeProject(body.cwd);
+    const projects = await listProjects();
+    return NextResponse.json({ ok: true, projects });
+  } catch (error) {
+    return NextResponse.json({ error: String(error) }, { status: 500 });
+  }
+}

package/app/api/reports/[id]/route.ts

@@ -0,0 +1,108 @@
+import { NextResponse } from "next/server";
+import {
+  applyReportUpdate,
+  generateReportFromSession,
+  readReport,
+  writeReport,
+  type AnalysisReport,
+  type AnalysisReportUpdate,
+} from "@/lib/report-store";
+import { loadCodexSessionContext, resolveSessionPath } from "@/lib/session-reader";
+
+export const dynamic = "force-dynamic";
+
+async function loadSessionForReport(sessionId: string): Promise<{
+  cwd: string;
+  title: string;
+  report: AnalysisReport;
+  context?: import("@/lib/types").SessionContext;
+}> {
+  const cwd = await resolveSessionPath(sessionId);
+  if (!cwd) throw new Error("Session not found");
+
+  const title = "Analysis Report";
+  const report = readReport(sessionId, cwd, title);
+
+  const context = (await loadCodexSessionContext(sessionId, cwd).catch(() => null))?.context;
+
+  return { cwd, title, report, context };
+}
+
+export async function GET(
+  _req: Request,
+  { params }: { params: Promise<{ id: string }> }
+) {
+  const { id } = await params;
+  try {
+    const { report } = await loadSessionForReport(id);
+    return NextResponse.json({ report });
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return NextResponse.json({ error: message }, { status: message === "Session not found" ? 404 : 500 });
+  }
+}
+
+export async function PUT(
+  req: Request,
+  { params }: { params: Promise<{ id: string }> }
+) {
+  const { id } = await params;
+  try {
+    const body = await req.json() as { report?: AnalysisReport };
+    if (!body.report || typeof body.report !== "object") {
+      return NextResponse.json({ error: "report is required" }, { status: 400 });
+    }
+    const { cwd, title } = await loadSessionForReport(id);
+    const report = writeReport({
+      ...body.report,
+      schemaVersion: 1,
+      sessionId: id,
+      cwd,
+      title: body.report.title || title,
+    });
+    return NextResponse.json({ report });
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return NextResponse.json({ error: message }, { status: message === "Session not found" ? 404 : 500 });
+  }
+}
+
+export async function POST(
+  req: Request,
+  { params }: { params: Promise<{ id: string }> }
+) {
+  const { id } = await params;
+  try {
+    const body = await req.json().catch(() => ({})) as {
+      action?: string;
+      update?: AnalysisReportUpdate;
+      updateKey?: string;
+      leafId?: string | null;
+      topic?: string;
+    };
+    const { title, report, context } = await loadSessionForReport(id);
+    const action = body.action ?? "generate";
+    if (action === "apply_update") {
+      if (!body.update || typeof body.update !== "object") {
+        return NextResponse.json({ error: "update is required" }, { status: 400 });
+      }
+      const saved = writeReport(applyReportUpdate(report, body.update, typeof body.updateKey === "string" ? body.updateKey : undefined));
+      return NextResponse.json({ report: saved });
+    }
+
+    if (action !== "generate") {
+      return NextResponse.json({ error: "Unsupported action" }, { status: 400 });
+    }
+
+    if (!context || context.messages.length === 0) {
+      return NextResponse.json({ report });
+    }
+
+    const generated = generateReportFromSession({ report, context, sessionTitle: title, topic: body.topic });
+    const saved = writeReport(generated);
+    return NextResponse.json({ report: saved });
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return NextResponse.json({ error: message }, { status: message === "Session not found" ? 404 : 500 });
+  }
+}