capman 0.4.2 → 0.4.4

package/dist/esm/logger.d.ts

@@ -0,0 +1,21 @@
+export type LogLevel = 'silent' | 'error' | 'warn' | 'info' | 'debug';
+export declare class Logger {
+    private level;
+    constructor(level?: LogLevel);
+    setLevel(level: LogLevel): void;
+    error(msg: string, ...args: unknown[]): void;
+    warn(msg: string, ...args: unknown[]): void;
+    info(msg: string, ...args: unknown[]): void;
+    debug(msg: string, ...args: unknown[]): void;
+}
+export declare const logger: Logger;
+/**
+ * Set the global log level for capman.
+ *
+ * @example
+ * import { setLogLevel } from 'capman'
+ * setLogLevel('debug') // see everything
+ * setLogLevel('info')  // see key steps
+ * setLogLevel('silent') // no output (default)
+ */
+export declare function setLogLevel(level: LogLevel): void;

package/dist/esm/matcher.d.ts

@@ -0,0 +1,6 @@
+import type { Manifest, MatchResult } from './types';
+export declare function match(query: string, manifest: Manifest): MatchResult;
+export interface LLMMatcherOptions {
+    llm: (prompt: string) => Promise<string>;
+}
+export declare function matchWithLLM(query: string, manifest: Manifest, options: LLMMatcherOptions): Promise<MatchResult>;

package/dist/esm/matcher.js

@@ -76,9 +76,6 @@ function extractParams(query, cap) {
         // e.g. "profile for johndoe" → johndoe
         //      "articles by jane"   → jane
         //      "tag javascript"     → javascript
-        // Use param name and description as hints for what to look for
-        const paramHints = [param.name, ...param.description.toLowerCase().split(/\s+/)]
-            .filter(w => w.length > 2);
         // Try keyword-based extraction first
         const keywords = [
             `for `, `by `, `about `, `named `, `called `,
@@ -203,29 +200,28 @@ export async function matchWithLLM(query, manifest, options) {
   "reasoning": "<one sentence>",
   "extracted_params": { "<param_name>": "<value or null>" }
   }`;
-    try {
-        const raw = await options.llm(prompt);
-        const clean = raw.replace(/```json|```/g, '').trim();
-        const parsed = JSON.parse(clean);
-        const isOOS = parsed.matched_capability === 'OUT_OF_SCOPE';
-        const capability = isOOS
-            ? null
-            : manifest.capabilities.find(c => c.id === parsed.matched_capability) ?? null;
-        return {
-            capability,
-            confidence: parsed.confidence,
-            intent: isOOS ? 'out_of_scope' : parsed.intent,
-            extractedParams: parsed.extracted_params ?? {},
-            reasoning: parsed.reasoning,
-            candidates: capability ? [{
-                    capabilityId: capability.id,
-                    score: parsed.confidence,
-                    matched: true,
-                }] : [],
-        };
-    }
-    catch (err) {
-        logger.warn(`LLM match failed, falling back to keyword matcher: ${err}`);
-        return match(query, manifest);
+    const raw = await options.llm(prompt);
+    const clean = raw.replace(/```json|```/g, '').trim();
+    const parsed = JSON.parse(clean);
+    const isOOS = parsed.matched_capability === 'OUT_OF_SCOPE';
+    const capability = isOOS
+        ? null
+        : manifest.capabilities.find(c => c.id === parsed.matched_capability) ?? null;
+    // If LLM returned an unknown capability ID, treat as out of scope
+    const effectivelyOOS = isOOS || capability === null;
+    if (!effectivelyOOS && capability === null) {
+        logger.warn(`LLM returned unknown capability ID: "${parsed.matched_capability}" — treating as out_of_scope`);
     }
+    return {
+        capability,
+        confidence: effectivelyOOS ? 0 : parsed.confidence,
+        intent: effectivelyOOS ? 'out_of_scope' : parsed.intent,
+        extractedParams: parsed.extracted_params ?? {},
+        reasoning: parsed.reasoning ?? 'No reasoning provided',
+        candidates: capability ? [{
+                capabilityId: capability.id,
+                score: parsed.confidence,
+                matched: true,
+            }] : [],
+    };
 }

package/dist/esm/parser.d.ts

@@ -0,0 +1,10 @@
+import type { CapmanConfig } from './types';
+export interface ParseResult {
+    config: CapmanConfig;
+    stats: {
+        total: number;
+        skipped: number;
+        warnings: string[];
+    };
+}
+export declare function parseOpenAPI(specPathOrUrl: string): Promise<ParseResult>;

package/dist/esm/parser.js

@@ -245,7 +245,8 @@ function toSnakeCase(str) {
         .replace(/[-\s]+/g, '_')
         .toLowerCase()
         .replace(/^_/, '')
-        .replace(/__+/g, '_');
+        .replace(/__+/g, '_')
+        .replace(/_$/, '');
 }
 function toHumanName(id) {
     return id

package/dist/esm/resolver.d.ts

@@ -0,0 +1,21 @@
+import type { MatchResult, ResolveResult } from './types';
+export interface AuthContext {
+    /** Whether the current request is authenticated */
+    isAuthenticated: boolean;
+    /** Current user's role */
+    role?: 'user' | 'admin';
+    /** Current user's ID — injected into session params */
+    userId?: string;
+}
+export interface ResolveOptions {
+    baseUrl?: string;
+    fetch?: typeof globalThis.fetch;
+    dryRun?: boolean;
+    headers?: Record<string, string>;
+    auth?: AuthContext;
+    /** Number of retries on failure (default: 0) */
+    retries?: number;
+    /** Timeout in milliseconds (default: 5000) */
+    timeoutMs?: number;
+}
+export declare function resolve(matchResult: MatchResult, params?: Record<string, unknown>, options?: ResolveOptions): Promise<ResolveResult>;

package/dist/esm/resolver.js

@@ -43,7 +43,7 @@ export async function resolve(matchResult, params = {}, options = {}) {
     // ── Session param injection ───────────────────────────────────────────────
     // Inject auth.userId into any params marked as source: 'session'
     const enrichedParams = { ...params };
-    if (options.auth?.userId) {
+    if (options.auth?.userId !== undefined) {
         for (const param of capability.params) {
             if (param.source === 'session') {
                 enrichedParams[param.name] = options.auth.userId;
@@ -172,7 +172,9 @@ async function resolveApi(resolver, params, options) {
 function resolveNav(resolver, params) {
     let destination = resolver.destination;
     for (const [key, value] of Object.entries(params)) {
-        destination = destination.replace(`{${key}}`, String(value));
+        if (value === null || value === undefined)
+            continue;
+        destination = destination.replace(`{${key}}`, encodeURIComponent(String(value)));
     }
     return { success: true, resolverType: 'nav', navTarget: destination };
 }
@@ -180,6 +182,8 @@ function buildUrl(baseUrl, urlPath, params) {
     let resolved = urlPath;
     const unused = {};
     for (const [key, value] of Object.entries(params)) {
+        if (value === null || value === undefined)
+            continue; // never write null into URLs
         if (resolved.includes(`{${key}}`)) {
             resolved = resolved.replace(`{${key}}`, encodeURIComponent(String(value)));
         }