profclaw 2.0.0 → 2.3.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/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