qlogicagent 0.2.1 → 0.4.0

package/dist/skills/qmemory-adapter.d.ts

@@ -1,52 +0,0 @@
-import type { MemoryIngestOptions, MemoryProvider } from "qlogicagent-runtime-contracts";
-/** A pre-extracted memory item ready to be stored (no LLM needed). */
-export interface ExtractedMemoryItem {
-    text: string;
-    category?: string;
-    importance?: number;
-    speaker?: string;
-    event_date?: string;
-    tags?: string[];
-}
-/** Configuration for the QMemory HTTP adapter. */
-export interface QMemoryAdapterConfig {
-    /** Base URL of the qmemory server (e.g. "http://localhost:18800"). */
-    baseUrl: string;
-    /** Optional API key for authentication. */
-    apiKey?: string;
-    /** Request timeout in milliseconds (default: 5000). */
-    timeoutMs?: number;
-    /** Prefix prepended to userId for multi-tenant isolation. */
-    userIdPrefix?: string;
-}
-/** Health status returned by qmemory `/v1/health/`. */
-export interface QMemoryHealthStatus {
-    status: string;
-    version: string;
-    memoryCount: number;
-    dbSizeBytes: number;
-    embeddingModel: string;
-    uptimeSeconds: number;
-}
-/**
- * Create a MemoryProvider backed by a QMemory HTTP server.
- *
- * @example
- * ```ts
- * const provider = createQMemoryAdapter({
- *   baseUrl: "http://localhost:18800",
- *   apiKey: "sk-...",
- * });
- *
- * const results = await provider.search("last meeting notes", "alice");
- * await provider.ingest([{ role: "user", content: "..." }], "alice");
- * ```
- */
-export declare function createQMemoryAdapter(config: QMemoryAdapterConfig): MemoryProvider & {
-    /** Check qmemory server health. */
-    health(): Promise<QMemoryHealthStatus>;
-    /** Write pre-extracted memories (no LLM extraction on qmemory side). */
-    ingestExtracted(items: ExtractedMemoryItem[], userId: string, options?: MemoryIngestOptions): Promise<{
-        memoriesAdded: number;
-    }>;
-};

package/dist/skills/qmemory-adapter.js

@@ -1,165 +0,0 @@
-// ============================================================
-// QMemory HTTP adapter — implements MemoryProvider against the
-// QMemory REST API (v1).
-//
-// This is a Hub-ready, provider-agnostic adapter that can be
-// plugged into any consumer of the MemoryProvider contract.
-// ============================================================
-const DEFAULT_TIMEOUT_MS = 5_000;
-const PROVIDER_ID = "qmemory";
-/**
- * Create a MemoryProvider backed by a QMemory HTTP server.
- *
- * @example
- * ```ts
- * const provider = createQMemoryAdapter({
- *   baseUrl: "http://localhost:18800",
- *   apiKey: "sk-...",
- * });
- *
- * const results = await provider.search("last meeting notes", "alice");
- * await provider.ingest([{ role: "user", content: "..." }], "alice");
- * ```
- */
-export function createQMemoryAdapter(config) {
-    const baseUrl = config.baseUrl.replace(/\/+$/, "");
-    const timeoutMs = config.timeoutMs ?? DEFAULT_TIMEOUT_MS;
-    function resolveUserId(userId) {
-        return config.userIdPrefix ? `${config.userIdPrefix}:${userId}` : userId;
-    }
-    function buildHeaders() {
-        const headers = {
-            "Accept": "application/json",
-        };
-        if (config.apiKey) {
-            headers["Authorization"] = `Bearer ${config.apiKey}`;
-        }
-        return headers;
-    }
-    async function request(pathname, init) {
-        const url = `${baseUrl}${pathname}`;
-        const controller = new AbortController();
-        const timer = setTimeout(() => controller.abort(), timeoutMs);
-        try {
-            const response = await fetch(url, {
-                ...init,
-                headers: { ...buildHeaders(), ...init?.headers },
-                signal: controller.signal,
-            });
-            if (!response.ok) {
-                const text = await response.text().catch(() => "");
-                throw new Error(`QMemory ${init?.method ?? "GET"} ${pathname} returned ${response.status}: ${text.slice(0, 200)}`);
-            }
-            return await response.json();
-        }
-        finally {
-            clearTimeout(timer);
-        }
-    }
-    return {
-        providerId: PROVIDER_ID,
-        async search(query, userId, options) {
-            const resolvedUserId = resolveUserId(userId);
-            const limit = options?.limit ?? 10;
-            const params = new URLSearchParams({
-                q: query,
-                user_id: resolvedUserId,
-                limit: String(limit),
-            });
-            const result = await request(`/v1/memories/search/?${params.toString()}`);
-            return (result.memories ?? [])
-                .filter((m) => m.id && m.text)
-                .map((m) => ({
-                blockId: m.id,
-                text: m.text,
-                score: typeof m.importance === "number" ? m.importance : 0,
-                source: PROVIDER_ID,
-                metadata: m.metadata,
-            }));
-        },
-        async ingest(messages, userId, options) {
-            const resolvedUserId = resolveUserId(userId);
-            await request("/v1/memories/", {
-                method: "POST",
-                headers: { "Content-Type": "application/json" },
-                body: JSON.stringify({
-                    user_id: resolvedUserId,
-                    messages: messages.map((m) => ({
-                        role: m.role,
-                        content: m.content,
-                        ...(m.timestamp ? { timestamp: m.timestamp } : {}),
-                    })), extraction_mode: "none", ...(options?.sessionId ? { session_id: options.sessionId } : {}),
-                    ...(options?.source ? { metadata: { source: options.source } } : {}),
-                    run_async: true,
-                }),
-            });
-        },
-        async health() {
-            const raw = await request("/v1/health/");
-            return {
-                status: raw.status ?? "unknown",
-                version: raw.version ?? "",
-                memoryCount: raw.memory_count ?? 0,
-                dbSizeBytes: raw.db_size_bytes ?? 0,
-                embeddingModel: raw.embedding_model ?? "",
-                uptimeSeconds: raw.uptime_seconds ?? 0,
-            };
-        },
-        async addText(text, userId, options) {
-            const resolvedUserId = resolveUserId(userId);
-            const result = await request("/v1/memories/", {
-                method: "POST",
-                headers: { "Content-Type": "application/json" },
-                body: JSON.stringify({
-                    user_id: resolvedUserId,
-                    text,
-                    extraction_mode: "none",
-                    ...(options?.sessionId ? { session_id: options.sessionId } : {}),
-                    ...(options?.source ? { metadata: { source: options.source } } : {}),
-                }),
-            });
-            return { memoriesAdded: result.memories_added ?? 0 };
-        },
-        async ingestExtracted(items, userId, options) {
-            if (items.length === 0)
-                return { memoriesAdded: 0 };
-            const resolvedUserId = resolveUserId(userId);
-            const results = await Promise.allSettled(items.map((item) => request("/v1/memories/", {
-                method: "POST",
-                headers: { "Content-Type": "application/json" },
-                body: JSON.stringify({
-                    user_id: resolvedUserId,
-                    text: item.text,
-                    extraction_mode: "none",
-                    ...(options?.sessionId ? { session_id: options.sessionId } : {}),
-                    metadata: {
-                        ...(options?.source ? { source: options.source } : {}),
-                        ...(item.category ? { category: item.category } : {}),
-                        ...(typeof item.importance === "number" ? { importance: item.importance } : {}),
-                        ...(item.speaker ? { speaker: item.speaker } : {}),
-                        ...(item.event_date ? { event_date: item.event_date } : {}),
-                        ...(item.tags?.length ? { tags: item.tags } : {}),
-                    },
-                }),
-            })));
-            let total = 0;
-            for (const r of results) {
-                if (r.status === "fulfilled") {
-                    total += r.value.memories_added ?? 1;
-                }
-            }
-            return { memoriesAdded: total };
-        },
-        async remove(memoryId) {
-            try {
-                await request(`/v1/memories/${encodeURIComponent(memoryId)}/`, {
-                    method: "DELETE",
-                });
-                return true;
-            }
-            catch {
-                return false;
-            }
-        },
-    };
-}

package/dist/skills/skill-frontmatter.d.ts

@@ -1,19 +0,0 @@
-import type { ParsedSkillFrontmatter, SkillInvocationPolicy, SkillMetadata } from "./skill-types.js";
-/**
- * Parse a YAML-like frontmatter block into a flat key→value record.
- * Uses a lightweight line parser to avoid a YAML library dependency.
- */
-export declare function parseFrontmatter(content: string): ParsedSkillFrontmatter;
-/**
- * Resolve structured metadata from the `metadata:` frontmatter field.
- * Expects `metadata: {"openclaw": {...}}` (JSON format).
- */
-export declare function resolveSkillMetadata(frontmatter: ParsedSkillFrontmatter): SkillMetadata | undefined;
-/**
- * Resolve invocation policy from frontmatter fields.
- */
-export declare function resolveSkillInvocationPolicy(frontmatter: ParsedSkillFrontmatter): SkillInvocationPolicy;
-/**
- * Get the canonical key for a skill (metadata.skillKey or skill.name).
- */
-export declare function resolveSkillKey(skillName: string, metadata?: SkillMetadata): string;

package/dist/skills/skill-frontmatter.js

@@ -1,344 +0,0 @@
-// ---------------------------------------------------------------------------
-// SKILL.md frontmatter parser — portable, zero external dependencies.
-// Mirrors openclaw/src/markdown/frontmatter.ts + src/agents/skills/frontmatter.ts
-// but without YAML library (uses simple line parser + JSON5-free metadata).
-// ---------------------------------------------------------------------------
-// ---------------------------------------------------------------------------
-// Block extraction
-// ---------------------------------------------------------------------------
-function extractFrontmatterBlock(content) {
-    const normalized = content.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
-    if (!normalized.startsWith("---")) {
-        return undefined;
-    }
-    const endIndex = normalized.indexOf("\n---", 3);
-    if (endIndex === -1) {
-        return undefined;
-    }
-    return normalized.slice(4, endIndex);
-}
-// ---------------------------------------------------------------------------
-// Line parser (handles both inline and multi-line values)
-// ---------------------------------------------------------------------------
-function stripQuotes(value) {
-    if ((value.startsWith('"') && value.endsWith('"')) ||
-        (value.startsWith("'") && value.endsWith("'"))) {
-        return value.slice(1, -1);
-    }
-    return value;
-}
-function extractMultiLineValue(lines, startIndex) {
-    const valueLines = [];
-    let i = startIndex + 1;
-    while (i < lines.length) {
-        const line = lines[i];
-        if (line.length > 0 && !line.startsWith(" ") && !line.startsWith("\t")) {
-            break;
-        }
-        valueLines.push(line);
-        i += 1;
-    }
-    return { value: valueLines.join("\n").trim(), linesConsumed: i - startIndex };
-}
-/**
- * Parse a YAML-like frontmatter block into a flat key→value record.
- * Uses a lightweight line parser to avoid a YAML library dependency.
- */
-export function parseFrontmatter(content) {
-    const block = extractFrontmatterBlock(content);
-    if (!block) {
-        return {};
-    }
-    const result = {};
-    const lines = block.split("\n");
-    let i = 0;
-    while (i < lines.length) {
-        const line = lines[i];
-        const match = line.match(/^([\w-]+):\s*(.*)$/);
-        if (!match) {
-            i += 1;
-            continue;
-        }
-        const key = match[1];
-        const inlineValue = match[2].trim();
-        if (!key) {
-            i += 1;
-            continue;
-        }
-        // Check for multi-line value
-        if (!inlineValue && i + 1 < lines.length) {
-            const nextLine = lines[i + 1];
-            if (nextLine.startsWith(" ") || nextLine.startsWith("\t")) {
-                const { value, linesConsumed } = extractMultiLineValue(lines, i);
-                if (value) {
-                    result[key] = value;
-                }
-                i += linesConsumed;
-                continue;
-            }
-        }
-        const value = stripQuotes(inlineValue);
-        if (value) {
-            result[key] = value;
-        }
-        i += 1;
-    }
-    return result;
-}
-// ---------------------------------------------------------------------------
-// Metadata resolver (from `metadata:` JSON block)
-// ---------------------------------------------------------------------------
-function parseMetadataJson(raw) {
-    // Try direct JSON first: `metadata: {"openclaw": {...}}`
-    try {
-        const parsed = JSON.parse(raw);
-        if (parsed && typeof parsed === "object") {
-            const obj = parsed;
-            const nested = obj["openclaw"];
-            if (nested && typeof nested === "object") {
-                return nested;
-            }
-            return obj;
-        }
-    }
-    catch {
-        // Not JSON — fall through to YAML-like parser
-    }
-    // Handle YAML-like multi-line: `key: value` per line
-    return parseYamlLikeMetadata(raw);
-}
-/**
- * Parse simple YAML-like `key: value` lines where values may be JSON
- * literals (objects, arrays, booleans, numbers) or plain strings.
- */
-function parseYamlLikeMetadata(raw) {
-    const result = {};
-    let found = false;
-    for (const line of raw.split("\n")) {
-        const trimmed = line.trim();
-        if (!trimmed)
-            continue;
-        const m = trimmed.match(/^([\w-]+):\s*(.+)$/);
-        if (!m)
-            continue;
-        const key = m[1];
-        const val = m[2].trim();
-        found = true;
-        // Try JSON parse for objects / arrays / booleans / numbers
-        try {
-            result[key] = JSON.parse(val);
-        }
-        catch {
-            // Plain string — normalise booleans / numbers
-            if (val === "true")
-                result[key] = true;
-            else if (val === "false")
-                result[key] = false;
-            else if (/^-?\d+(\.\d+)?$/.test(val))
-                result[key] = Number(val);
-            else
-                result[key] = val;
-        }
-    }
-    return found ? result : undefined;
-}
-function normalizeStringList(input) {
-    if (!input)
-        return [];
-    if (Array.isArray(input)) {
-        return input.map((v) => String(v).trim()).filter(Boolean);
-    }
-    if (typeof input === "string") {
-        return input
-            .split(",")
-            .map((v) => v.trim())
-            .filter(Boolean);
-    }
-    return [];
-}
-function parseBool(value, fallback) {
-    if (value === undefined)
-        return fallback;
-    const lower = value.toLowerCase().trim();
-    if (lower === "true" || lower === "1" || lower === "yes")
-        return true;
-    if (lower === "false" || lower === "0" || lower === "no")
-        return false;
-    return fallback;
-}
-// ---------------------------------------------------------------------------
-// Install spec validation (safe input normalization)
-// ---------------------------------------------------------------------------
-const BREW_FORMULA_PATTERN = /^[A-Za-z0-9][A-Za-z0-9@+._/-]*$/;
-const GO_MODULE_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._~+\-/]*(?:@[A-Za-z0-9][A-Za-z0-9._~+\-/]*)?$/;
-const UV_PACKAGE_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._\-[\]=<>!~+,]*$/;
-const NPM_SPEC_PATTERN = /^(@[a-z0-9][\w.\-]*\/)?[a-z0-9][\w.\-]*(@[~^]?[\d.*]+[\w.\-+]*)?$/;
-function normalizeSafeBrewFormula(raw) {
-    if (typeof raw !== "string")
-        return undefined;
-    const formula = raw.trim();
-    if (!formula || formula.startsWith("-") || formula.includes("\\") || formula.includes("..")) {
-        return undefined;
-    }
-    return BREW_FORMULA_PATTERN.test(formula) ? formula : undefined;
-}
-function normalizeSafeNpmSpec(raw) {
-    if (typeof raw !== "string")
-        return undefined;
-    const spec = raw.trim();
-    if (!spec || spec.startsWith("-"))
-        return undefined;
-    return NPM_SPEC_PATTERN.test(spec) ? spec : undefined;
-}
-function normalizeSafeGoModule(raw) {
-    if (typeof raw !== "string")
-        return undefined;
-    const mod = raw.trim();
-    if (!mod || mod.startsWith("-") || mod.includes("\\") || mod.includes("://"))
-        return undefined;
-    return GO_MODULE_PATTERN.test(mod) ? mod : undefined;
-}
-function normalizeSafeUvPackage(raw) {
-    if (typeof raw !== "string")
-        return undefined;
-    const pkg = raw.trim();
-    if (!pkg || pkg.startsWith("-") || pkg.includes("\\") || pkg.includes("://"))
-        return undefined;
-    return UV_PACKAGE_PATTERN.test(pkg) ? pkg : undefined;
-}
-function normalizeSafeDownloadUrl(raw) {
-    if (typeof raw !== "string")
-        return undefined;
-    const value = raw.trim();
-    if (!value || /\s/.test(value))
-        return undefined;
-    try {
-        const parsed = new URL(value);
-        if (parsed.protocol !== "http:" && parsed.protocol !== "https:")
-            return undefined;
-        return parsed.toString();
-    }
-    catch {
-        return undefined;
-    }
-}
-function parseInstallSpec(input) {
-    if (!input || typeof input !== "object")
-        return undefined;
-    const raw = input;
-    const kindRaw = typeof raw.kind === "string" ? raw.kind : typeof raw.type === "string" ? raw.type : "";
-    const kind = kindRaw.trim().toLowerCase();
-    const ALLOWED_KINDS = ["brew", "node", "go", "uv", "download"];
-    if (!ALLOWED_KINDS.includes(kind))
-        return undefined;
-    const spec = { kind: kind };
-    if (typeof raw.id === "string")
-        spec.id = raw.id;
-    if (typeof raw.label === "string")
-        spec.label = raw.label;
-    const bins = normalizeStringList(raw.bins);
-    if (bins.length > 0)
-        spec.bins = bins;
-    const osList = normalizeStringList(raw.os);
-    if (osList.length > 0)
-        spec.os = osList;
-    // Kind-specific fields
-    const formula = normalizeSafeBrewFormula(raw.formula) ?? normalizeSafeBrewFormula(raw.cask);
-    if (formula)
-        spec.formula = formula;
-    if (kind === "node") {
-        const pkg = normalizeSafeNpmSpec(raw.package);
-        if (pkg)
-            spec.package = pkg;
-    }
-    else if (kind === "uv") {
-        const pkg = normalizeSafeUvPackage(raw.package);
-        if (pkg)
-            spec.package = pkg;
-    }
-    const mod = normalizeSafeGoModule(raw.module);
-    if (mod)
-        spec.module = mod;
-    const url = normalizeSafeDownloadUrl(raw.url);
-    if (url)
-        spec.url = url;
-    if (typeof raw.archive === "string")
-        spec.archive = raw.archive;
-    if (typeof raw.extract === "boolean")
-        spec.extract = raw.extract;
-    if (typeof raw.stripComponents === "number")
-        spec.stripComponents = raw.stripComponents;
-    if (typeof raw.targetDir === "string")
-        spec.targetDir = raw.targetDir;
-    // Validate required field per kind
-    if (kind === "brew" && !spec.formula)
-        return undefined;
-    if (kind === "node" && !spec.package)
-        return undefined;
-    if (kind === "go" && !spec.module)
-        return undefined;
-    if (kind === "uv" && !spec.package)
-        return undefined;
-    if (kind === "download" && !spec.url)
-        return undefined;
-    return spec;
-}
-// ---------------------------------------------------------------------------
-// Public API
-// ---------------------------------------------------------------------------
-/**
- * Resolve structured metadata from the `metadata:` frontmatter field.
- * Expects `metadata: {"openclaw": {...}}` (JSON format).
- */
-export function resolveSkillMetadata(frontmatter) {
-    const raw = frontmatter["metadata"];
-    if (!raw)
-        return undefined;
-    const metadataObj = parseMetadataJson(raw);
-    if (!metadataObj)
-        return undefined;
-    const requiresRaw = typeof metadataObj.requires === "object" && metadataObj.requires !== null
-        ? metadataObj.requires
-        : undefined;
-    const requires = requiresRaw
-        ? {
-            bins: normalizeStringList(requiresRaw.bins),
-            anyBins: normalizeStringList(requiresRaw.anyBins),
-            env: normalizeStringList(requiresRaw.env),
-            config: normalizeStringList(requiresRaw.config),
-        }
-        : undefined;
-    const installRaw = Array.isArray(metadataObj.install)
-        ? metadataObj.install
-        : [];
-    const install = installRaw
-        .map((entry) => parseInstallSpec(entry))
-        .filter((entry) => Boolean(entry));
-    const osRaw = normalizeStringList(metadataObj.os);
-    return {
-        always: typeof metadataObj.always === "boolean" ? metadataObj.always : undefined,
-        emoji: typeof metadataObj.emoji === "string" ? metadataObj.emoji : undefined,
-        homepage: typeof metadataObj.homepage === "string" ? metadataObj.homepage : undefined,
-        skillKey: typeof metadataObj.skillKey === "string" ? metadataObj.skillKey : undefined,
-        primaryEnv: typeof metadataObj.primaryEnv === "string" ? metadataObj.primaryEnv : undefined,
-        os: osRaw.length > 0 ? osRaw : undefined,
-        category: typeof metadataObj.category === "string" ? metadataObj.category : undefined,
-        requires,
-        install: install.length > 0 ? install : undefined,
-    };
-}
-/**
- * Resolve invocation policy from frontmatter fields.
- */
-export function resolveSkillInvocationPolicy(frontmatter) {
-    return {
-        userInvocable: parseBool(frontmatter["user-invocable"], true),
-        disableModelInvocation: parseBool(frontmatter["disable-model-invocation"], false),
-    };
-}
-/**
- * Get the canonical key for a skill (metadata.skillKey or skill.name).
- */
-export function resolveSkillKey(skillName, metadata) {
-    return metadata?.skillKey ?? skillName;
-}

package/dist/skills/skill-guard.d.ts

@@ -1,23 +0,0 @@
-import type { SkillFsDeps, SkillPathDeps, SkillScanFinding, SkillScanOptions, SkillScanSummary } from "./skill-types.js";
-/**
- * Scan a source string for security findings.
- * This is a pure function — no file I/O.
- */
-export declare function scanSource(source: string, filePath: string): SkillScanFinding[];
-export interface SkillGuardDeps {
-    fs: SkillFsDeps;
-    path: SkillPathDeps;
-}
-/**
- * Scan an entire skill directory for security issues.
- * Returns a summary with per-file findings.
- */
-export declare function scanSkillDirectory(deps: SkillGuardDeps, skillDir: string, opts?: SkillScanOptions): Promise<SkillScanSummary>;
-/**
- * Quick check: does this source have any critical findings?
- */
-export declare function hasCriticalFindings(source: string, filePath: string): boolean;
-/**
- * Check if a file extension is scannable by the guard.
- */
-export declare function isScannable(filePath: string, pathDeps: SkillPathDeps): boolean;