@ai-setting/roy-agent-cli 1.3.15 → 1.3.17

package/dist/core/src/env/prompt/types.d.ts

@@ -0,0 +1,159 @@
+/**
+ * @fileoverview PromptComponent Types
+ */
+import { z } from "zod";
+/**
+ * 单个 Prompt 路径配置（外部加载）
+ */
+export declare const PromptPathSchema: z.ZodObject<{
+    /** 路径类型 */
+    type: z.ZodEnum<["file", "directory"]>;
+    /** 路径 */
+    path: z.ZodString;
+    /** 名称（可选，用于覆盖文件名校验） */
+    name: z.ZodOptional<z.ZodString>;
+    /** 是否递归加载子目录（仅 directory 类型） */
+    recursive: z.ZodDefault<z.ZodBoolean>;
+    /** 文件扩展名过滤（仅 directory 类型） */
+    extension: z.ZodDefault<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    name?: string;
+    path?: string;
+    type?: "file" | "directory";
+    recursive?: boolean;
+    extension?: string;
+}, {
+    name?: string;
+    path?: string;
+    type?: "file" | "directory";
+    recursive?: boolean;
+    extension?: string;
+}>;
+export type PromptPath = z.infer<typeof PromptPathSchema>;
+/**
+ * PromptComponent 配置 Schema
+ */
+export declare const PromptConfigSchema: z.ZodObject<{
+    /** 外部 Prompt 路径列表（可选） */
+    promptPaths: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        /** 路径类型 */
+        type: z.ZodEnum<["file", "directory"]>;
+        /** 路径 */
+        path: z.ZodString;
+        /** 名称（可选，用于覆盖文件名校验） */
+        name: z.ZodOptional<z.ZodString>;
+        /** 是否递归加载子目录（仅 directory 类型） */
+        recursive: z.ZodDefault<z.ZodBoolean>;
+        /** 文件扩展名过滤（仅 directory 类型） */
+        extension: z.ZodDefault<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        name?: string;
+        path?: string;
+        type?: "file" | "directory";
+        recursive?: boolean;
+        extension?: string;
+    }, {
+        name?: string;
+        path?: string;
+        type?: "file" | "directory";
+        recursive?: boolean;
+        extension?: string;
+    }>, "many">>;
+    /** 默认 prompt 名称 */
+    defaultName: z.ZodDefault<z.ZodString>;
+    /** 变量前缀 */
+    variablePrefix: z.ZodDefault<z.ZodString>;
+    /** 变量后缀 */
+    variableSuffix: z.ZodDefault<z.ZodString>;
+    /** 严格模式：变量未定义时报错 */
+    strictMode: z.ZodDefault<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    promptPaths?: {
+        name?: string;
+        path?: string;
+        type?: "file" | "directory";
+        recursive?: boolean;
+        extension?: string;
+    }[];
+    defaultName?: string;
+    variablePrefix?: string;
+    variableSuffix?: string;
+    strictMode?: boolean;
+}, {
+    promptPaths?: {
+        name?: string;
+        path?: string;
+        type?: "file" | "directory";
+        recursive?: boolean;
+        extension?: string;
+    }[];
+    defaultName?: string;
+    variablePrefix?: string;
+    variableSuffix?: string;
+    strictMode?: boolean;
+}>;
+export type PromptConfig = z.infer<typeof PromptConfigSchema>;
+/**
+ * Prompt 来源类型
+ */
+export type PromptSource = "built-in" | "file" | "directory" | "inline";
+/**
+ * Prompt 条目
+ */
+export interface PromptEntry {
+    /** 唯一名称 */
+    name: string;
+    /** Prompt 内容 */
+    content: string;
+    /** 来源 */
+    source: PromptSource;
+    /** 原始文件路径 */
+    filePath?: string;
+    /** 是否可覆盖（内置 prompt 不可覆盖） */
+    overridable: boolean;
+    /** 加载时间 */
+    loadedAt: number;
+}
+/**
+ * Prompt Hook 点常量
+ */
+export declare const PromptHookPoints: {
+    readonly BEFORE_RENDER: "prompt.before-render";
+    readonly AFTER_RENDER: "prompt.after-render";
+};
+/**
+ * Prompt Hook 上下文（用于统一 Hook 系统）
+ */
+export interface PromptHookContext {
+    /** Prompt 名称 */
+    name: string;
+    /** 原始内容 */
+    originalContent: string;
+    /** 渲染后的内容（after hook 可修改） */
+    renderedContent: string;
+    /** 渲染变量 */
+    variables: Record<string, string>;
+}
+/**
+ * Render Hook 上下文（别名，保持向后兼容）
+ */
+export type RenderHookContext = PromptHookContext;
+/**
+ * Prompt Hook（使用统一 Hook 接口）
+ */
+export interface PromptHook {
+    name: string;
+    priority?: number;
+    execute(ctx: {
+        data: PromptHookContext;
+        phase: "before" | "after";
+    }): void | Promise<void>;
+}
+/**
+ * Prompt Hook Map（保持向后兼容）
+ */
+export type PromptHookMap = {
+    "before.render"?: PromptHook[];
+    "after.render"?: PromptHook[];
+};
+//# sourceMappingURL=types.d.ts.map

package/dist/core/src/env/prompt/types.js

@@ -0,0 +1,48 @@
+/**
+ * @fileoverview PromptComponent Types
+ */
+import { z } from "zod";
+// ============================================================================
+// Config Schema
+// ============================================================================
+/**
+ * 单个 Prompt 路径配置（外部加载）
+ */
+export const PromptPathSchema = z.object({
+    /** 路径类型 */
+    type: z.enum(["file", "directory"]),
+    /** 路径 */
+    path: z.string(),
+    /** 名称（可选，用于覆盖文件名校验） */
+    name: z.string().optional(),
+    /** 是否递归加载子目录（仅 directory 类型） */
+    recursive: z.boolean().default(true),
+    /** 文件扩展名过滤（仅 directory 类型） */
+    extension: z.string().default(".md"),
+});
+/**
+ * PromptComponent 配置 Schema
+ */
+export const PromptConfigSchema = z.object({
+    /** 外部 Prompt 路径列表（可选） */
+    promptPaths: z.array(PromptPathSchema).default([]),
+    /** 默认 prompt 名称 */
+    defaultName: z.string().default("default"),
+    /** 变量前缀 */
+    variablePrefix: z.string().default("{{"),
+    /** 变量后缀 */
+    variableSuffix: z.string().default("}}"),
+    /** 严格模式：变量未定义时报错 */
+    strictMode: z.boolean().default(false),
+});
+// ============================================================================
+// Hooks
+// ============================================================================
+/**
+ * Prompt Hook 点常量
+ */
+export const PromptHookPoints = {
+    BEFORE_RENDER: "prompt.before-render",
+    AFTER_RENDER: "prompt.after-render",
+};
+//# sourceMappingURL=types.js.map

package/dist/core/src/env/session/hooks.d.ts

@@ -0,0 +1,15 @@
+/**
+ * @fileoverview Session Hooks
+ */
+import type { Hook } from "../component";
+import type { SessionHookType as SHT, SessionHookContext as SHC } from "./types";
+export type SessionHookType = SHT;
+export type SessionHookContext = SHC;
+/**
+ * Session hook registration
+ */
+export interface SessionHookRegistration {
+    type: SessionHookType;
+    hook: Hook;
+}
+//# sourceMappingURL=hooks.d.ts.map

package/dist/core/src/env/session/hooks.js

@@ -0,0 +1,5 @@
+/**
+ * @fileoverview Session Hooks
+ */
+export {};
+//# sourceMappingURL=hooks.js.map

package/dist/core/src/env/session/index.d.ts

@@ -0,0 +1,19 @@
+/**
+ * @fileoverview Session Component Index
+ *
+ * Session management component for Environment
+ */
+export { SessionComponent } from "./session-component";
+export { SessionMessageConverter } from "./session-message-converter";
+export type { Session, SessionMessage, SessionConfig, SessionCheckpoint, // (new)
+SessionCheckpointsMeta, // (new)
+CreateSessionOptions, UpdateSessionOptions, ListSessionsOptions, AddMessageOptions, CompactOptions, // (new)
+CompactResult, // (new)
+CompactPreview, // (new)
+GetContextOptions, // (new)
+GetContextResult, // (new)
+GetMessagesOptions, } from "./types";
+export type { SessionStore } from "./session-store";
+export { MemorySessionStore } from "./storage/memory";
+export * from "./hooks";
+//# sourceMappingURL=index.d.ts.map

package/dist/core/src/env/session/index.js

@@ -0,0 +1,13 @@
+/**
+ * @fileoverview Session Component Index
+ *
+ * Session management component for Environment
+ */
+// Component
+export { SessionComponent } from "./session-component.js";
+// Message Converter
+export { SessionMessageConverter } from "./session-message-converter.js";
+export { MemorySessionStore } from "./storage/memory.js";
+// Hooks (includes SessionHookType and SessionHookContext)
+export * from "./hooks.js";
+//# sourceMappingURL=index.js.map

package/dist/core/src/env/session/search-query-parser.d.ts

@@ -0,0 +1,42 @@
+/**
+ * @fileoverview Search Query Parser
+ *
+ * Parses search query strings into structured terms for message matching.
+ *
+ * Supported syntax:
+ * - AND: term1 AND term2 (both required, default behavior)
+ * - OR: term1 OR term2 (either required)
+ * - NOT: term1 NOT term2 (term1 required, term2 excluded)
+ * - Quoted phrases: "exact phrase"
+ * - Default: AND (space-separated terms are ANDed together)
+ *
+ * @example
+ * parseSearchQuery("hello world")        // { required: ["hello", "world"], excluded: [], phrases: [] }
+ * parseSearchQuery("hello OR world")    // { required: ["hello", "world"], orMode: true }
+ * parseSearchQuery("hello NOT world")   // { required: ["hello"], excluded: ["world"] }
+ * parseSearchQuery('"exact phrase"')    // { required: [], excluded: [], phrases: ["exact phrase"] }
+ */
+export interface ParsedQuery {
+    /** Required terms (AND logic by default) */
+    required: string[];
+    /** Terms to exclude */
+    excluded: string[];
+    /** Exact phrases to match */
+    phrases: string[];
+}
+/**
+ * Parse a search query string into structured terms
+ *
+ * @param query - Search query string
+ * @returns Parsed query structure
+ */
+export declare function parseSearchQuery(query: string): ParsedQuery;
+/**
+ * Check if content matches parsed query
+ *
+ * @param content - Content to search
+ * @param query - Parsed query structure
+ * @returns true if content matches query
+ */
+export declare function matchesQuery(content: string, query: ParsedQuery): boolean;
+//# sourceMappingURL=search-query-parser.d.ts.map

package/dist/core/src/env/session/search-query-parser.js

@@ -0,0 +1,141 @@
+/**
+ * @fileoverview Search Query Parser
+ *
+ * Parses search query strings into structured terms for message matching.
+ *
+ * Supported syntax:
+ * - AND: term1 AND term2 (both required, default behavior)
+ * - OR: term1 OR term2 (either required)
+ * - NOT: term1 NOT term2 (term1 required, term2 excluded)
+ * - Quoted phrases: "exact phrase"
+ * - Default: AND (space-separated terms are ANDed together)
+ *
+ * @example
+ * parseSearchQuery("hello world")        // { required: ["hello", "world"], excluded: [], phrases: [] }
+ * parseSearchQuery("hello OR world")    // { required: ["hello", "world"], orMode: true }
+ * parseSearchQuery("hello NOT world")   // { required: ["hello"], excluded: ["world"] }
+ * parseSearchQuery('"exact phrase"')    // { required: [], excluded: [], phrases: ["exact phrase"] }
+ */
+/**
+ * Parse a search query string into structured terms
+ *
+ * @param query - Search query string
+ * @returns Parsed query structure
+ */
+export function parseSearchQuery(query) {
+    const result = {
+        required: [],
+        excluded: [],
+        phrases: [],
+    };
+    if (!query || !query.trim()) {
+        return result;
+    }
+    // Step 1: Extract quoted phrases first
+    const phraseRegex = /"([^"]+)"/g;
+    let match;
+    while ((match = phraseRegex.exec(query)) !== null) {
+        result.phrases.push(match[1].toLowerCase());
+    }
+    // Remove quoted phrases from query
+    query = query.replace(phraseRegex, "");
+    // Step 2: Normalize whitespace
+    query = query.replace(/\s+/g, " ").trim();
+    if (!query) {
+        return result;
+    }
+    // Step 3: Tokenize query by splitting on operators
+    // Need to handle each operator separately since they can chain
+    const parts = [];
+    let remaining = query;
+    // Match single operators one at a time
+    const singleOpRegex = /\s+(AND|OR|NOT)\s+/gi;
+    let opMatch;
+    while ((opMatch = singleOpRegex.exec(remaining)) !== null) {
+        const op = opMatch[1].toUpperCase();
+        const beforeText = remaining.slice(0, opMatch.index).trim();
+        if (beforeText) {
+            parts.push({ text: beforeText, operator: undefined });
+        }
+        parts.push({ text: op, operator: op });
+        remaining = remaining.slice(opMatch.index + opMatch[0].length);
+        // Reset regex lastIndex for remaining portion
+        singleOpRegex.lastIndex = 0;
+    }
+    // Remaining text after last operator
+    if (remaining.trim()) {
+        parts.push({ text: remaining.trim(), operator: undefined });
+    }
+    // Step 4: Build result
+    let currentOperator = "AND";
+    for (const part of parts) {
+        if (part.operator) {
+            // This is an operator
+            currentOperator = part.operator;
+        }
+        else {
+            // This is text - split into words
+            // Use Unicode-aware word matching (supports Chinese, Japanese, etc.)
+            const wordRegex = /[\w\u4e00-\u9fff\u3040-\u309f\u30a0-\u30ff]+/gu;
+            const words = part.text.match(wordRegex) || [];
+            for (const word of words) {
+                const lowerWord = word.toLowerCase();
+                // Check if this word is an operator
+                if (lowerWord === "and" || lowerWord === "or" || lowerWord === "not") {
+                    currentOperator = lowerWord.toUpperCase();
+                    continue;
+                }
+                // Apply current operator to this word
+                if (currentOperator === "NOT") {
+                    if (!result.excluded.includes(lowerWord)) {
+                        result.excluded.push(lowerWord);
+                    }
+                }
+                else {
+                    if (!result.required.includes(lowerWord)) {
+                        result.required.push(lowerWord);
+                    }
+                }
+                // Reset to AND after processing a word
+                currentOperator = "AND";
+            }
+        }
+    }
+    return result;
+}
+/**
+ * Check if content matches parsed query
+ *
+ * @param content - Content to search
+ * @param query - Parsed query structure
+ * @returns true if content matches query
+ */
+export function matchesQuery(content, query) {
+    if (!content) {
+        return query.required.length === 0 && query.phrases.length === 0;
+    }
+    const lowerContent = content.toLowerCase();
+    // Step 1: Check excluded terms first (highest priority)
+    for (const term of query.excluded) {
+        if (lowerContent.includes(term.toLowerCase())) {
+            return false;
+        }
+    }
+    // Step 2: Check required phrases
+    for (const phrase of query.phrases) {
+        if (!lowerContent.includes(phrase)) {
+            return false;
+        }
+    }
+    // Step 3: Check required terms (AND logic)
+    // If no required terms, match (only exclusions and phrases applied)
+    if (query.required.length > 0) {
+        for (const term of query.required) {
+            if (!lowerContent.includes(term)) {
+                return false;
+            }
+        }
+    }
+    return true;
+}
+//# sourceMappingURL=search-query-parser.js.map

package/dist/core/src/env/session/search-query-parser.test.d.ts

@@ -0,0 +1,14 @@
+/**
+ * @fileoverview Search Query Parser Tests
+ *
+ * TDD: Tests for parseSearchQuery function
+ *
+ * 期望行为：
+ * - 支持 AND 操作符（默认）
+ * - 支持 OR 操作符
+ * - 支持 NOT 操作符
+ * - 支持引号短语匹配
+ * - 大小写不敏感
+ */
+export {};
+//# sourceMappingURL=search-query-parser.test.d.ts.map