@seqyuan/annodex 0.1.12 → 0.1.14

package/app/api/models/route.ts

@@ -1,67 +0,0 @@
-/**
- * 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

@@ -1,42 +0,0 @@
-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

@@ -1,152 +0,0 @@
-/**
- * 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

@@ -1,154 +0,0 @@
-/**
- * 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

@@ -1,51 +0,0 @@
-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

@@ -1,83 +0,0 @@
-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

@@ -1,108 +0,0 @@
-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 });
-  }
-}