@nifrajs/cli 1.0.0-beta.3 → 1.0.0

package/src/mcp.ts

@@ -46,6 +46,7 @@ import {
   type McpToolContext,
   rpcError,
 } from "./mcp-protocol.ts"
+import { loadTypesCorpus } from "./types-search.ts"
 
 /** Path to a sibling child entry (`mcp-run` / `mcp-render` / `mcp-ws`), resolved next to this module (`.ts` in
  * dev, `.js` once built). Each runs in a FRESH subprocess per call so the project's current code loads. */
@@ -124,8 +125,9 @@ type PipeSubprocess = ReturnType<typeof Bun.spawn> & {
  * reused across newline-delimited `{ id, input }` requests, replying `{ id, output }`. The same machinery
  * powers both `nifra_run warm` and `nifra_render warm` — `child` selects which engine, `label` shapes the
  * cancellation message. The owning handler ({@link createWarmHandler}) fingerprints the source tree and
- * replaces the worker when a file changes, so warm reuse never serves a stale result. */
-class WarmWorker {
+ * replaces the worker when a file changes, so warm reuse never serves a stale result. Exported for the
+ * concurrency test that proves a single per-request cancel doesn't tear down the shared worker. */
+export class WarmWorker {
   private readonly proc: PipeSubprocess
   private readonly pending = new Map<
     number,
@@ -176,8 +178,11 @@ class WarmWorker {
     const id = ++this.nextId
     return new Promise((resolve, reject) => {
       const abort = (): void => {
+        // Per-request cancel: drop just THIS id and resolve its cancellation. The worker is shared
+        // across concurrent requests (`pending` is id-keyed for exactly this reason), so killing the
+        // process here would reject every OTHER in-flight request via the `exited` handler and force a
+        // cold rebuild. Leave it hot — `createWarmHandler` already replaces it on file change.
         this.pending.delete(id)
-        this.stop()
         const reason = typeof signal?.reason === "string" ? `: ${signal.reason}` : ""
         resolve(`${this.label} cancelled${reason}.`)
       }
@@ -764,7 +769,7 @@ export function projectTools(
     },
     // nifra_docs + nifra_example are project-independent (corpus-backed); the shared factory keeps their
     // definitions identical to the CLI HTTP server and the site's edge worker.
-    ...docsTools(loadDocsCorpus, loadExamplesCorpus),
+    ...docsTools(loadDocsCorpus, loadExamplesCorpus, loadTypesCorpus),
     {
       name: "nifra_scaffold",
       description:
@@ -900,7 +905,7 @@ export async function runMcpServer(cwd: string, version: string): Promise<void>
       allResources.push(...(ns.features.resources ?? []))
       allPrompts.push(...(ns.features.prompts ?? []))
     }
-    tools = [...docsTools(loadDocsCorpus, loadExamplesCorpus), ...allTools]
+    tools = [...docsTools(loadDocsCorpus, loadExamplesCorpus, loadTypesCorpus), ...allTools]
     features = { resources: allResources, prompts: allPrompts }
   } else {
     const loadAppCached = createCachedAppLoader(cwd)

package/src/types-search.ts

@@ -0,0 +1,113 @@
+/**
+ * `nifra_types` — the EXACT TypeScript of every exported `@nifrajs/*` symbol. The corpus is `types.json`
+ * (written into this package by `bun run gen:llms`): each entry's `signature` is the literal declaration
+ * parsed from the package's BUILT `.d.ts` with the TS compiler — a clean signature, never prose, never
+ * truncated. So an agent that needs the precise shape of a type (`RateLimitStore`, `RouteSchema`, a
+ * function signature) gets the authoritative source here and never has to read a `.d.ts` file.
+ *
+ * Lookup by `name` is exact (case-insensitive); `query` keyword-scores over the name (heavy) + the
+ * signature/doc body; no args → a per-package index of the available type names.
+ */
+
+import { countBodyHits, queryTermGroups, tokenize, tokenSetHas } from "./search-terms.ts"
+
+export interface TypeEntry {
+  readonly name: string
+  readonly kind: "interface" | "type" | "class" | "function" | "enum" | "const"
+  readonly package: string
+  /** The literal declaration text from the `.d.ts` — a clean signature, no implementation. */
+  readonly signature: string
+  /** The declaration's JSDoc block, if any. */
+  readonly doc?: string
+}
+
+export interface ScoredType extends TypeEntry {
+  readonly score: number
+}
+
+/** Exact (case-insensitive) name lookup — returns every declaration with that name (a name can exist in
+ * more than one package). */
+export function lookupType(types: readonly TypeEntry[], name: string): TypeEntry[] {
+  const wanted = name.trim().toLowerCase()
+  return types.filter((t) => t.name.toLowerCase() === wanted)
+}
+
+/** Keyword-score types: a term in the name is worth far more than one in the signature/doc body. */
+export function searchTypes(
+  types: readonly TypeEntry[],
+  query: string,
+  limit: number,
+): ScoredType[] {
+  const terms = queryTermGroups(query)
+  if (terms.length === 0) return []
+  const scored: ScoredType[] = []
+  for (const t of types) {
+    const nameTokens = new Set(tokenize(t.name))
+    const body = `${t.signature} ${t.doc ?? ""}`.toLowerCase()
+    let score = 0
+    for (const term of terms) {
+      if (tokenSetHas(nameTokens, term)) score += 8
+      score += countBodyHits(body, term, 4)
+    }
+    if (score > 0) scored.push({ ...t, score })
+  }
+  return scored.sort((a, b) => b.score - a.score || a.name.localeCompare(b.name)).slice(0, limit)
+}
+
+function renderEntry(t: TypeEntry): string {
+  const head = `## ${t.name} — ${t.kind}, \`${t.package}\``
+  const doc = t.doc ? `${t.doc}\n` : ""
+  return `${head}\n\n\`\`\`ts\n${doc}${t.signature}\n\`\`\``
+}
+
+/**
+ * Render the tool result. `name` → the exact declaration(s); else `query` → the top matches; else a
+ * per-package index of type names. The signatures are authoritative (generated from the built `.d.ts`),
+ * so this is the complete answer — there is no need to read a `.d.ts` file.
+ */
+export function renderTypesResult(
+  types: readonly TypeEntry[],
+  name: string | undefined,
+  query: string | undefined,
+  limit: number,
+): string {
+  if (name !== undefined && name.trim() !== "") {
+    const hits = lookupType(types, name)
+    if (hits.length === 0) {
+      return `No exported type named ${JSON.stringify(name)} in @nifrajs/*. Call nifra_types with a \`query\` (e.g. "rate limit") or no args for the per-package index of names.`
+    }
+    return hits.map(renderEntry).join("\n\n---\n\n")
+  }
+  if (query !== undefined && query.trim() !== "") {
+    const matches = searchTypes(types, query, limit)
+    if (matches.length === 0) {
+      return `No types matched ${JSON.stringify(query)}. Try a broader term, pass an exact \`name\`, or call with no args for the index.`
+    }
+    return matches.map(renderEntry).join("\n\n---\n\n")
+  }
+  const byPkg = new Map<string, string[]>()
+  for (const t of types) {
+    const list = byPkg.get(t.package) ?? []
+    list.push(t.name)
+    byPkg.set(t.package, list)
+  }
+  const index = [...byPkg.entries()]
+    .sort(([a], [b]) => a.localeCompare(b))
+    .map(([pkg, names]) => `- **${pkg}**: ${names.sort().join(", ")}`)
+    .join("\n")
+  return `# nifra types — index (${types.length} exported symbols; pass \`name\` for the exact declaration, or \`query\` to search)\n\nSignatures are generated from the built \`.d.ts\` — authoritative + complete. Use this instead of reading any \`.d.ts\` file.\n\n${index}`
+}
+
+/** Load the bundled type corpus (`docs/types.json`), resolved relative to this module so it works from
+ * `src/` (dev) and `dist/` (published) alike. */
+export async function loadTypesCorpus(): Promise<TypeEntry[] | undefined> {
+  const url = new URL("../docs/types.json", import.meta.url)
+  try {
+    const text = await Bun.file(url).text()
+    if (text.length === 0) return undefined
+    const parsed = JSON.parse(text) as TypeEntry[]
+    return Array.isArray(parsed) && parsed.length > 0 ? parsed : undefined
+  } catch {
+    return undefined
+  }
+}