@portel/photon-core 2.1.2 → 2.2.0

package/src/schema-extractor.ts

@@ -142,6 +142,11 @@ export class SchemaExtractor {
           const isStateful = this.hasStatefulTag(jsdoc);
           const autorun = this.hasAutorunTag(jsdoc);
 
+          // Daemon features
+          const webhook = this.extractWebhook(jsdoc, methodName);
+          const scheduled = this.extractScheduled(jsdoc, methodName);
+          const locked = this.extractLocked(jsdoc, methodName);
+
           tools.push({
             name: methodName,
             description,
@@ -154,6 +159,10 @@ export class SchemaExtractor {
             ...(yields && yields.length > 0 ? { yields } : {}),
             ...(isStateful ? { isStateful: true } : {}),
             ...(autorun ? { autorun: true } : {}),
+            // Daemon features
+            ...(webhook !== undefined ? { webhook } : {}),
+            ...(scheduled ? { scheduled } : {}),
+            ...(locked !== undefined ? { locked } : {}),
           });
         }
       };
@@ -699,6 +708,8 @@ export class SchemaExtractor {
         .replace(/\{@label\s+[^}]+\}/g, '')
         .replace(/\{@placeholder\s+[^}]+\}/g, '')
         .replace(/\{@hint\s+[^}]+\}/g, '')
+        .replace(/\{@hidden\s*\}/g, '')
+        .replace(/\{@accept\s+[^}]+\}/g, '')
         .replace(/\s+/g, ' ')  // Collapse multiple spaces
         .trim();
       paramDocs.set(paramName, cleanDesc);
@@ -710,7 +721,7 @@ export class SchemaExtractor {
   /**
    * Extract parameter constraints from JSDoc @param tags
    * Supports inline tags: {@min}, {@max}, {@pattern}, {@format}, {@default}, {@unique},
-   * {@example}, {@multipleOf}, {@deprecated}, {@readOnly}, {@writeOnly}
+   * {@example}, {@multipleOf}, {@deprecated}, {@readOnly}, {@writeOnly}, {@accept}
    */
   private extractParamConstraints(jsdocContent: string): Map<string, any> {
     const constraints = new Map<string, any>();
@@ -847,6 +858,12 @@ export class SchemaExtractor {
         paramConstraints.hidden = true;
       }
 
+      // Extract {@accept pattern} - file type filter for file picker (e.g., "*.ts,*.js" or ".ts,.js")
+      const acceptMatch = description.match(/\{@accept\s+([^}]+)\}/);
+      if (acceptMatch) {
+        paramConstraints.accept = acceptMatch[1].trim();
+      }
+
       if (Object.keys(paramConstraints).length > 0) {
         constraints.set(paramName, paramConstraints);
       }
@@ -957,6 +974,10 @@ export class SchemaExtractor {
       if (constraints.hidden === true) {
         s.hidden = true;
       }
+      // Apply accept pattern for file picker filtering
+      if (constraints.accept !== undefined) {
+        s.accept = constraints.accept;
+      }
     };
 
     // Apply to anyOf schemas or direct schema
@@ -1006,6 +1027,79 @@ export class SchemaExtractor {
     return /@autorun/i.test(jsdocContent);
   }
 
+  // ═══════════════════════════════════════════════════════════════════════════════
+  // DAEMON FEATURE EXTRACTION
+  // ═══════════════════════════════════════════════════════════════════════════════
+
+  /**
+   * Extract webhook configuration from @webhook tag or handle* prefix
+   * - @webhook → use method name as path
+   * - @webhook stripe → custom path "stripe"
+   * - handle* prefix → auto-detected as webhook
+   */
+  private extractWebhook(jsdocContent: string, methodName: string): boolean | string | undefined {
+    // Check for @webhook tag with optional path
+    // Path must start with a word character (to exclude JSDoc asterisks and closing)
+    const webhookMatch = jsdocContent.match(/@webhook(?:\s+(\w[\w\-\/]*))?/i);
+    if (webhookMatch) {
+      const path = webhookMatch[1]?.trim();
+      // Return custom path if specified, otherwise true for bare @webhook
+      return path || true;
+    }
+
+    // Check for handle* prefix (convention)
+    if (methodName.startsWith('handle')) {
+      return true;
+    }
+
+    return undefined;
+  }
+
+  /**
+   * Extract scheduled cron expression from @scheduled, @cron tag, or scheduled* prefix
+   * - @scheduled 0 0 * * * → cron expression
+   * - @cron 0 0 * * * → cron expression
+   * - scheduled* prefix requires @cron tag for the expression
+   */
+  private extractScheduled(jsdocContent: string, methodName: string): string | undefined {
+    // Check for @scheduled with cron expression
+    const scheduledMatch = jsdocContent.match(/@scheduled\s+([*\d,\-\/]+(?:\s+[*\d,\-\/]+){4})/i);
+    if (scheduledMatch) {
+      return scheduledMatch[1].trim();
+    }
+
+    // Check for @cron tag
+    const cronMatch = jsdocContent.match(/@cron\s+([*\d,\-\/]+(?:\s+[*\d,\-\/]+){4})/i);
+    if (cronMatch) {
+      return cronMatch[1].trim();
+    }
+
+    // scheduled* prefix without explicit cron - method exists but needs @cron
+    if (methodName.startsWith('scheduled') && !cronMatch && !scheduledMatch) {
+      // Could log warning: scheduled* method missing @cron tag
+      return undefined;
+    }
+
+    return undefined;
+  }
+
+  /**
+   * Extract lock configuration from @locked tag
+   * - @locked → use method name as lock
+   * - @locked board:write → custom lock name
+   */
+  private extractLocked(jsdocContent: string, methodName: string): boolean | string | undefined {
+    // Lock name must start with a word character (to exclude JSDoc asterisks and closing)
+    const lockedMatch = jsdocContent.match(/@locked(?:\s+(\w[\w\-:]*))?/i);
+    if (lockedMatch) {
+      const lockName = lockedMatch[1]?.trim();
+      // Return custom lock name if specified, otherwise true for bare @locked
+      return lockName || true;
+    }
+
+    return undefined;
+  }
+
   /**
    * Extract URI pattern from @Static tag
    * Example: @Static github://repos/{owner}/{repo}/readme
@@ -1093,13 +1187,16 @@ export class SchemaExtractor {
   }
 
   /**
-   * Extract icon from @icon tag
+   * Extract icon from @icon tag (standalone, not inside layout hints)
    * Example: @icon calculator
    * Example: @icon 🧮
    * Example: @icon mdi:calculator
+   * Note: Does NOT match @icon inside layout hints like {@icon fieldname}
    */
   private extractIcon(jsdocContent: string): string | undefined {
-    const iconMatch = jsdocContent.match(/@icon\s+([^\s@*]+)/i);
+    // First, remove layout hints blocks to avoid matching @icon inside them
+    const withoutLayoutHints = jsdocContent.replace(/\{[^}]+\}/g, '');
+    const iconMatch = withoutLayoutHints.match(/@icon\s+([^\s@*,]+)/i);
     if (iconMatch) {
       return iconMatch[1].trim();
     }

package/src/types.ts

@@ -63,6 +63,29 @@ export interface ExtractedSchema {
   isStateful?: boolean;
   /** True if this method should auto-execute when selected (idempotent, no required params) */
   autorun?: boolean;
+
+  // ═══ DAEMON FEATURES ═══
+
+  /**
+   * Webhook endpoint path (from @webhook tag or handle* prefix)
+   * - true: use method name as path (e.g., handleGithubPush → /webhook/handleGithubPush)
+   * - string: custom path (e.g., @webhook stripe → /webhook/stripe)
+   */
+  webhook?: boolean | string;
+
+  /**
+   * Cron schedule expression (from @scheduled or @cron tag, or scheduled* prefix)
+   * Standard 5-field format: minute hour day-of-month month day-of-week
+   * Example: "0 0 * * *" (daily at midnight)
+   */
+  scheduled?: string;
+
+  /**
+   * Distributed lock name (from @locked tag)
+   * - true: use method name as lock (e.g., batchUpdate → lock "batchUpdate")
+   * - string: custom lock name (e.g., @locked board:write)
+   */
+  locked?: boolean | string;
 }
 
 export interface PhotonMCPClass {