profclaw 2.0.0 → 2.4.0

package/dist/cli/utils/api.d.ts

@@ -4,6 +4,15 @@ export interface ApiResponse<T = unknown> {
     data?: T;
     error?: string;
 }
+/**
+ * Auto-detect the profClaw server by probing /health on candidate ports.
+ * Caches the result so subsequent calls don't re-probe.
+ * Uses a shared promise to deduplicate concurrent calls.
+ *
+ * Exported so callers that need the base URL directly (e.g. TUI, REPL, print
+ * mode) can share the same detection logic without duplicating it.
+ */
+export declare function detectBaseUrl(): Promise<string>;
 /**
  * Make an API request to the profClaw server
  */

package/dist/cli/utils/api.js

@@ -1,12 +1,68 @@
 import { getConfig } from './config.js';
+/** Ports to probe when looking for a running profClaw server. */
+const CANDIDATE_PORTS = ['3000', '3001', '3002', '9100'];
+let resolvedBaseUrl;
+let detectPromise;
+/**
+ * Auto-detect the profClaw server by probing /health on candidate ports.
+ * Caches the result so subsequent calls don't re-probe.
+ * Uses a shared promise to deduplicate concurrent calls.
+ *
+ * Exported so callers that need the base URL directly (e.g. TUI, REPL, print
+ * mode) can share the same detection logic without duplicating it.
+ */
+export async function detectBaseUrl() {
+    if (resolvedBaseUrl)
+        return resolvedBaseUrl;
+    if (detectPromise)
+        return detectPromise;
+    detectPromise = doDetect();
+    return detectPromise;
+}
+async function doDetect() {
+    // If PORT env is set, use it directly (user knows best)
+    if (process.env.PORT) {
+        resolvedBaseUrl = `http://localhost:${process.env.PORT}`;
+        return resolvedBaseUrl;
+    }
+    // Check user-configured apiUrl from config file (not the default)
+    const config = getConfig();
+    const configPath = config.apiUrl;
+    const isUserConfigured = configPath && configPath !== 'http://localhost:3000';
+    if (isUserConfigured) {
+        resolvedBaseUrl = configPath;
+        return resolvedBaseUrl;
+    }
+    // Probe candidate ports for a running profClaw server
+    for (const port of CANDIDATE_PORTS) {
+        try {
+            const res = await fetch(`http://localhost:${port}/health`, {
+                signal: AbortSignal.timeout(1000),
+            });
+            if (res.ok) {
+                const body = await res.json();
+                if (body.service === 'profclaw') {
+                    resolvedBaseUrl = `http://localhost:${port}`;
+                    return resolvedBaseUrl;
+                }
+            }
+        }
+        catch {
+            // Port not responding or not profClaw — try next
+        }
+    }
+    // Fallback to default
+    resolvedBaseUrl = 'http://localhost:3000';
+    return resolvedBaseUrl;
+}
 /**
  * Make an API request to the profClaw server
  */
 export async function apiRequest(method, path, body) {
-    const config = getConfig();
-    const baseUrl = config.apiUrl || 'http://localhost:3000';
+    const baseUrl = await detectBaseUrl();
     const url = `${baseUrl}${path}`;
     try {
+        const config = getConfig();
         const headers = {
             'Content-Type': 'application/json',
         };

package/dist/costs/token-tracker.d.ts

@@ -2,6 +2,12 @@ export interface UsageSummary {
     totalTokens: number;
     inputTokens: number;
     outputTokens: number;
+    /** Prompt tokens served from provider cache (subset of inputTokens) */
+    cacheReadTokens: number;
+    /** Prompt tokens written to provider cache (subset of inputTokens) */
+    cacheWriteTokens: number;
+    /** cacheReadTokens / inputTokens, 0 when there is no input */
+    cacheHitRate: number;
     totalCost: number;
     taskCount: number;
     byModel: Record<string, {
@@ -22,7 +28,10 @@ export declare function initTokenTracker(): void;
 /**
  * Track usage from a chat/agentic session (not queue tasks)
  */
-export declare function trackChatUsage(model: string, totalTokens: number, inputTokens?: number, outputTokens?: number): void;
+export declare function trackChatUsage(model: string, totalTokens: number, inputTokens?: number, outputTokens?: number, cache?: {
+    cacheReadTokens?: number;
+    cacheWriteTokens?: number;
+}): void;
 /**
  * Get current usage summary
  */

package/dist/costs/token-tracker.js

@@ -1,5 +1,6 @@
 import { onTaskEvent } from '../queue/index.js';
-import { calculateCost } from './pricing.js';
+import { calculateCost, getModelPricing } from './pricing.js';
+import { cacheHitRate, calculateCachedInputCost, getCacheConfigForModel } from '../providers/prompt-cache.js';
 import { logger } from '../utils/logger.js';
 import { recordCost } from './persistence.js';
 // In-memory usage store
@@ -7,6 +8,9 @@ let globalUsage = {
     totalTokens: 0,
     inputTokens: 0,
     outputTokens: 0,
+    cacheReadTokens: 0,
+    cacheWriteTokens: 0,
+    cacheHitRate: 0,
     totalCost: 0,
     taskCount: 0,
     byModel: {},
@@ -81,16 +85,32 @@ function trackTaskUsage(task, result) {
         cost,
     });
 }
+/**
+ * Cost of a chat call. Uncached input bills at the model input rate; cache reads
+ * and writes bill at the configurable multipliers of that same rate. Output cost
+ * comes from the existing pricing table (calculateCost with zero input).
+ */
+function calculateChatCost(model, input, output, cacheRead, cacheWrite) {
+    if (cacheRead === 0 && cacheWrite === 0)
+        return calculateCost(model, input, output);
+    const inputCost = calculateCachedInputCost(input, cacheRead, cacheWrite, getModelPricing(model).inputRate, getCacheConfigForModel(model));
+    const outputCost = calculateCost(model, 0, output);
+    return Math.round((inputCost + outputCost) * 1_000_000) / 1_000_000;
+}
 /**
  * Track usage from a chat/agentic session (not queue tasks)
  */
-export function trackChatUsage(model, totalTokens, inputTokens, outputTokens) {
+export function trackChatUsage(model, totalTokens, inputTokens, outputTokens, cache) {
     const input = inputTokens ?? Math.floor(totalTokens * 0.7);
     const output = outputTokens ?? totalTokens - input;
-    const cost = calculateCost(model, input, output);
+    const cacheRead = cache?.cacheReadTokens ?? 0;
+    const cacheWrite = cache?.cacheWriteTokens ?? 0;
+    const cost = calculateChatCost(model, input, output, cacheRead, cacheWrite);
     globalUsage.totalTokens += totalTokens;
     globalUsage.inputTokens += input;
     globalUsage.outputTokens += output;
+    globalUsage.cacheReadTokens += cacheRead;
+    globalUsage.cacheWriteTokens += cacheWrite;
     globalUsage.totalCost += cost;
     globalUsage.taskCount += 1;
     const agentId = 'chat';
@@ -116,13 +136,22 @@ export function trackChatUsage(model, totalTokens, inputTokens, outputTokens) {
         source: 'chat',
         agentId: 'chat',
     });
-    logger.debug('Chat usage tracked', { model, tokens: totalTokens, cost });
+    logger.debug('Chat usage tracked', {
+        model,
+        tokens: totalTokens,
+        cost,
+        cacheReadTokens: cacheRead,
+        cacheWriteTokens: cacheWrite,
+    });
 }
 /**
  * Get current usage summary
  */
 export function getUsageSummary() {
-    return { ...globalUsage };
+    return {
+        ...globalUsage,
+        cacheHitRate: cacheHitRate(globalUsage.cacheReadTokens, globalUsage.inputTokens),
+    };
 }
 /**
  * Reset usage (for testing or billing cycles)
@@ -132,6 +161,9 @@ export function resetUsage() {
         totalTokens: 0,
         inputTokens: 0,
         outputTokens: 0,
+        cacheReadTokens: 0,
+        cacheWriteTokens: 0,
+        cacheHitRate: 0,
         totalCost: 0,
         taskCount: 0,
         byModel: {},

package/dist/cron/natural-language.d.ts

@@ -0,0 +1,54 @@
+/**
+ * Natural Language Cron Parser
+ *
+ * Converts human-readable scheduling descriptions into cron expressions
+ * and structured job parameters. This is the "just tell me what you want"
+ * layer that makes profClaw feel autonomous.
+ *
+ * Examples:
+ *   "every morning at 8am summarize GitHub notifications"
+ *   "every friday at 5pm send sprint report to slack"
+ *   "check server health every 30 minutes"
+ *   "once a day at midnight clean up old logs"
+ *   "every weekday at 9am pull RSS feeds and send digest to telegram"
+ */
+import type { CreateJobParams, DeliveryChannelType } from './scheduler.js';
+export interface ParsedSchedule {
+    cronExpression?: string;
+    intervalMs?: number;
+    runAt?: Date;
+    timezone: string;
+    confidence: number;
+    humanReadable: string;
+}
+export interface ParsedIntent {
+    action: string;
+    target?: string;
+    details: Record<string, string>;
+}
+export interface ParsedDelivery {
+    channel: DeliveryChannelType;
+    target: string;
+}
+export interface NaturalLanguageResult {
+    success: boolean;
+    schedule?: ParsedSchedule;
+    intent?: ParsedIntent;
+    delivery?: ParsedDelivery;
+    jobParams?: CreateJobParams;
+    rawInput: string;
+    error?: string;
+}
+/**
+ * Parse a natural language automation request into structured job params.
+ */
+export declare function parseNaturalLanguage(input: string): NaturalLanguageResult;
+/**
+ * Validate a cron expression (basic check).
+ */
+export declare function isValidCron(expression: string): boolean;
+/**
+ * Convert a cron expression to a human-readable string.
+ */
+export declare function cronToHuman(expression: string): string;
+//# sourceMappingURL=natural-language.d.ts.map