@seqyuan/annodex 0.1.11 → 0.1.12

package/app/api/skills/route.ts

@@ -0,0 +1,161 @@
+/**
+ * Skills API — reads Codex native skills from ~/.codex/skills and
+ * project-local .codex/skills.
+ */
+
+import { NextRequest, NextResponse } from "next/server";
+import { existsSync, readdirSync, readFileSync, statSync, writeFileSync } from "fs";
+import { join } from "path";
+import { getCodexHome } from "@/lib/codex-home";
+
+export const dynamic = "force-dynamic";
+export const runtime = "nodejs";
+
+interface SkillInfo {
+  name: string;
+  description: string;
+  filePath: string;
+  baseDir: string;
+  disableModelInvocation: boolean;
+  sourceInfo: {
+    source: "project" | "user" | "system";
+    scope: "project" | "user" | "system";
+  };
+}
+
+interface SkillMeta {
+  description: string;
+  disableModelInvocation: boolean;
+}
+
+function parseFrontMatter(content: string): Record<string, string | boolean> {
+  if (!content.startsWith("---\n")) return {};
+  const end = content.indexOf("\n---", 4);
+  if (end === -1) return {};
+  const raw = content.slice(4, end);
+  const meta: Record<string, string | boolean> = {};
+  for (const line of raw.split("\n")) {
+    const match = /^([A-Za-z0-9_-]+):\s*(.*)$/.exec(line.trim());
+    if (!match) continue;
+    const key = match[1];
+    const value = match[2].trim().replace(/^["']|["']$/g, "");
+    if (value === "true") meta[key] = true;
+    else if (value === "false") meta[key] = false;
+    else meta[key] = value;
+  }
+  return meta;
+}
+
+function readSkillMeta(skillMdPath: string): SkillMeta {
+  try {
+    const content = readFileSync(skillMdPath, "utf-8");
+    const frontMatter = parseFrontMatter(content);
+    const description = typeof frontMatter.description === "string"
+      ? frontMatter.description
+      : content.split("\n").find((line) => line.startsWith("# "))?.slice(2).trim()
+        ?? content.split("\n").find((line) => line.trim())?.trim()
+        ?? "";
+    return {
+      description,
+      disableModelInvocation: frontMatter.disableModelInvocation === true,
+    };
+  } catch {
+    return { description: "", disableModelInvocation: false };
+  }
+}
+
+function setSkillDisabled(skillMdPath: string, disabled: boolean): void {
+  const content = readFileSync(skillMdPath, "utf-8");
+  if (content.startsWith("---\n")) {
+    const end = content.indexOf("\n---", 4);
+    if (end !== -1) {
+      const frontMatter = content.slice(4, end);
+      const body = content.slice(end);
+      const lines = frontMatter.split("\n");
+      const idx = lines.findIndex((line) => /^disableModelInvocation\s*:/.test(line.trim()));
+      if (idx >= 0) lines[idx] = `disableModelInvocation: ${disabled}`;
+      else lines.push(`disableModelInvocation: ${disabled}`);
+      writeFileSync(skillMdPath, `---\n${lines.join("\n")}${body}`, "utf-8");
+      return;
+    }
+  }
+  writeFileSync(skillMdPath, `---\ndisableModelInvocation: ${disabled}\n---\n\n${content}`, "utf-8");
+}
+
+function collectSkills(baseDir: string, source: SkillInfo["sourceInfo"]["source"], skills: SkillInfo[]): void {
+  if (!existsSync(baseDir)) return;
+  for (const entry of readdirSync(baseDir)) {
+    const fullPath = join(baseDir, entry);
+    try {
+      if (!statSync(fullPath).isDirectory()) continue;
+      const skillMdPath = join(fullPath, "SKILL.md");
+      if (!existsSync(skillMdPath)) continue;
+      const meta = readSkillMeta(skillMdPath);
+      skills.push({
+        name: entry,
+        description: meta.description,
+        filePath: skillMdPath,
+        baseDir,
+        disableModelInvocation: meta.disableModelInvocation,
+        sourceInfo: {
+          source,
+          scope: source,
+        },
+      });
+    } catch {
+      // skip unreadable entries
+    }
+  }
+}
+
+export async function GET(req: NextRequest) {
+  const url = new URL(req.url);
+  const cwd = url.searchParams.get("cwd")?.trim();
+  const skills: SkillInfo[] = [];
+  const codexHome = getCodexHome();
+
+  try {
+    if (cwd) collectSkills(join(cwd, ".codex", "skills"), "project", skills);
+    collectSkills(join(codexHome, "skills"), "user", skills);
+    collectSkills(join(codexHome, "skills", ".system"), "system", skills);
+  } catch (error) {
+    return NextResponse.json({ error: String(error), skills: [] }, { status: 500 });
+  }
+
+  skills.sort((a, b) => {
+    const order = { project: 0, user: 1, system: 2 };
+    const bySource = order[a.sourceInfo.source] - order[b.sourceInfo.source];
+    return bySource || a.name.localeCompare(b.name);
+  });
+  return NextResponse.json({ skills });
+}
+
+export async function PATCH(req: Request) {
+  try {
+    const body = await req.json() as {
+      filePath?: unknown;
+      disableModelInvocation?: unknown;
+    };
+    if (typeof body.filePath !== "string" || !body.filePath.endsWith("/SKILL.md")) {
+      return NextResponse.json({ error: "filePath is required" }, { status: 400 });
+    }
+    if (typeof body.disableModelInvocation !== "boolean") {
+      return NextResponse.json({ error: "disableModelInvocation is required" }, { status: 400 });
+    }
+    if (!existsSync(body.filePath)) {
+      return NextResponse.json({ error: "Skill file not found" }, { status: 404 });
+    }
+    const homeSkills = join(getCodexHome(), "skills");
+    const filePath = body.filePath;
+    const allowed =
+      filePath.startsWith(`${homeSkills}/`) ||
+      filePath.includes("/.codex/skills/");
+    if (!allowed) {
+      return NextResponse.json({ error: "Skill path is outside Codex skills directories" }, { status: 403 });
+    }
+    setSkillDisabled(body.filePath, body.disableModelInvocation);
+    return NextResponse.json({ success: true });
+  } catch (error) {
+    return NextResponse.json({ error: String(error) }, { status: 500 });
+  }
+}

package/app/api/skills/search/route.ts

@@ -0,0 +1,121 @@
+import { NextResponse } from "next/server";
+import { runNpx } from "@/lib/npx";
+
+export const dynamic = "force-dynamic";
+
+const ANSI_RE = /\x1B\[[0-9;]*m/g;
+const DEFAULT_LIMIT = 50;
+const MIN_LIMIT = 1;
+const MAX_LIMIT = 50;
+const SEARCH_API_BASE = process.env.SKILLS_API_URL || "https://skills.sh";
+
+export interface SkillSearchResult {
+  package: string;
+  installs: string;
+  url: string;
+}
+
+interface SkillsApiSkill {
+  id?: string;
+  name?: string;
+  source?: string;
+  installs?: number;
+}
+
+interface SkillsApiResponse {
+  skills?: SkillsApiSkill[];
+}
+
+function parseLimit(value: unknown): number {
+  const num = typeof value === "number" ? value : Number(value);
+  if (!Number.isFinite(num)) return DEFAULT_LIMIT;
+  return Math.min(MAX_LIMIT, Math.max(MIN_LIMIT, Math.floor(num)));
+}
+
+function formatInstalls(count?: number): string {
+  if (!count || count <= 0) return "";
+  if (count >= 1_000_000) return `${(count / 1_000_000).toFixed(1).replace(/\.0$/, "")}M installs`;
+  if (count >= 1_000) return `${(count / 1_000).toFixed(1).replace(/\.0$/, "")}K installs`;
+  return `${count} install${count === 1 ? "" : "s"}`;
+}
+
+function parseSearchOutput(raw: string): SkillSearchResult[] {
+  const clean = raw.replace(ANSI_RE, "");
+  const results: SkillSearchResult[] = [];
+  const lines = clean.split("\n");
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i].trim();
+    // package line: "owner/repo@skill  NNK installs"
+    const pkgMatch = line.match(/^([\w.\-]+\/[\w.\-@:]+)\s+([\d.,]+[KMB]?\s+installs)$/);
+    if (pkgMatch) {
+      const urlLine = lines[i + 1]?.trim().replace(/^└\s*/, "");
+      results.push({
+        package: pkgMatch[1],
+        installs: pkgMatch[2],
+        url: urlLine?.startsWith("https://") ? urlLine : "",
+      });
+    }
+  }
+  return results;
+}
+
+async function searchSkillsApi(query: string, limit: number): Promise<SkillSearchResult[]> {
+  const url = `${SEARCH_API_BASE}/api/search?q=${encodeURIComponent(query)}&limit=${limit}`;
+  const res = await fetch(url, { cache: "no-store" });
+  if (!res.ok) throw new Error(`skills.sh search failed: HTTP ${res.status}`);
+
+  const data = (await res.json()) as SkillsApiResponse;
+  return (data.skills ?? [])
+    .map((skill) => {
+      const name = skill.name?.trim();
+      const source = skill.source?.trim();
+      const slug = skill.id?.trim();
+      if (!name || (!source && !slug)) return null;
+
+      const pkg = `${source || slug}@${name}`;
+      return {
+        package: pkg,
+        installs: formatInstalls(skill.installs),
+        url: slug ? `${SEARCH_API_BASE}/${slug}` : "",
+      };
+    })
+    .filter((skill): skill is SkillSearchResult => skill !== null)
+    .sort((a, b) => parseInstallCount(b.installs) - parseInstallCount(a.installs));
+}
+
+function parseInstallCount(installs: string): number {
+  const match = installs.match(/^([\d.]+)([KMB])?\s+installs?$/);
+  if (!match) return 0;
+  const value = Number(match[1]);
+  if (!Number.isFinite(value)) return 0;
+  const multiplier = match[2] === "B" ? 1_000_000_000 : match[2] === "M" ? 1_000_000 : match[2] === "K" ? 1_000 : 1;
+  return value * multiplier;
+}
+
+// POST /api/skills/search  body: { query: string, limit?: number }
+export async function POST(req: Request) {
+  try {
+    const { query, limit: rawLimit } = await req.json() as { query?: string; limit?: unknown };
+    if (!query?.trim()) return NextResponse.json({ error: "query required" }, { status: 400 });
+    const limit = parseLimit(rawLimit);
+
+    try {
+      const results = await searchSkillsApi(query.trim(), limit);
+      return NextResponse.json({ results });
+    } catch {
+      const { stdout, stderr } = await runNpx(["--yes", "skills", "find", query.trim()], {
+        timeout: 20000,
+        env: { ...process.env, FORCE_COLOR: "0" },
+      });
+
+      const results = parseSearchOutput(stdout + stderr).slice(0, limit);
+      return NextResponse.json({ results });
+    }
+  } catch (e: unknown) {
+    const err = e as { stdout?: string; stderr?: string; message?: string };
+    const raw = (err.stdout ?? "") + (err.stderr ?? "");
+    const results = raw ? parseSearchOutput(raw) : [];
+    if (results.length > 0) return NextResponse.json({ results });
+    return NextResponse.json({ error: err.message ?? String(e) }, { status: 500 });
+  }
+}

package/app/api/soul/route.ts

@@ -0,0 +1,47 @@
+import { NextResponse } from "next/server";
+import { readFileSync, writeFileSync, existsSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+
+function getConfigDir(): string {
+  return join(homedir(), ".config", "annodex");
+}
+
+function getSoulPath(): string {
+  const dir = getConfigDir();
+  const upper = join(dir, "SOUL.md");
+  const lower = join(dir, "soul.md");
+  // Read: uppercase first, fall back to lowercase
+  if (existsSync(upper)) return upper;
+  return lower;
+}
+
+// GET /api/soul — read global SOUL.md
+export async function GET() {
+  try {
+    const path = getSoulPath();
+    if (!existsSync(path)) {
+      return NextResponse.json({ content: "", exists: false });
+    }
+    const content = readFileSync(path, "utf-8");
+    return NextResponse.json({ content, exists: true, size: Buffer.byteLength(content, "utf-8") });
+  } catch (error) {
+    return NextResponse.json({ error: String(error) }, { status: 500 });
+  }
+}
+
+// PUT /api/soul — write global SOUL.md (always uppercase)
+export async function PUT(req: Request) {
+  try {
+    const body = await req.json() as { content?: string };
+    if (typeof body.content !== "string") {
+      return NextResponse.json({ error: "Missing 'content' field" }, { status: 400 });
+    }
+    // Always write uppercase
+    const path = join(getConfigDir(), "SOUL.md");
+    writeFileSync(path, body.content, "utf-8");
+    return NextResponse.json({ success: true });
+  } catch (error) {
+    return NextResponse.json({ error: String(error) }, { status: 500 });
+  }
+}

package/app/api/version/route.ts

@@ -0,0 +1,55 @@
+import { NextResponse } from "next/server";
+import { APP_PACKAGE_NAME, APP_UPDATE_COMMAND } from "@/lib/brand";
+import { readRuntimeState, type RuntimeState } from "@/lib/runtime-state";
+
+export const dynamic = "force-dynamic";
+
+const CURRENT_VERSION = process.env.NEXT_PUBLIC_APP_VERSION ?? "0.0.0";
+const LATEST_CACHE_TTL_MS = 5 * 60_000;
+
+let latestCache: { value: string | null; expiresAt: number } | null = null;
+
+interface VersionStatus {
+  current: string;
+  latest: string | null;
+  updateAvailable: boolean;
+  updateCommand: string;
+  runtime: RuntimeState | null;
+}
+
+async function fetchLatestVersion(): Promise<string | null> {
+  if (latestCache && latestCache.expiresAt > Date.now()) return latestCache.value;
+  const controller = new AbortController();
+  const timeout = setTimeout(() => controller.abort(), 3500);
+  try {
+    const res = await fetch(`https://registry.npmjs.org/${encodeURIComponent(APP_PACKAGE_NAME)}/latest`, {
+      cache: "no-store",
+      signal: controller.signal,
+    });
+    if (!res.ok) {
+      latestCache = { value: null, expiresAt: Date.now() + LATEST_CACHE_TTL_MS };
+      return null;
+    }
+    const data = await res.json() as { version?: unknown };
+    const latest = typeof data.version === "string" ? data.version : null;
+    latestCache = { value: latest, expiresAt: Date.now() + LATEST_CACHE_TTL_MS };
+    return latest;
+  } catch {
+    latestCache = { value: null, expiresAt: Date.now() + 60_000 };
+    return null;
+  } finally {
+    clearTimeout(timeout);
+  }
+}
+
+export async function GET() {
+  const latest = await fetchLatestVersion();
+  const payload: VersionStatus = {
+    current: CURRENT_VERSION,
+    latest,
+    updateAvailable: Boolean(latest && latest !== CURRENT_VERSION),
+    updateCommand: APP_UPDATE_COMMAND,
+    runtime: readRuntimeState(),
+  };
+  return NextResponse.json(payload);
+}