qlogicagent 0.2.1 → 0.3.0

package/dist/skills/skill-loader.js

@@ -1,303 +0,0 @@
-// ---------------------------------------------------------------------------
-// Skill discovery & loading — portable, DI-based.
-// Mirrors openclaw/src/agents/skills/workspace.ts logic but decoupled from
-// Node.js fs/path via SkillLoaderDeps.
-// ---------------------------------------------------------------------------
-import { parseFrontmatter, resolveSkillMetadata, resolveSkillInvocationPolicy } from "./skill-frontmatter.js";
-// ---------------------------------------------------------------------------
-// Default limits (match openclaw upstream)
-// ---------------------------------------------------------------------------
-const DEFAULT_LIMITS = {
-    maxCandidatesPerRoot: 300,
-    maxSkillsLoadedPerSource: 200,
-    maxSkillsInPrompt: 150,
-    maxSkillsPromptChars: 30_000,
-    maxSkillFileBytes: 256_000,
-};
-function resolveLimits(input) {
-    return {
-        maxCandidatesPerRoot: input?.maxCandidatesPerRoot ?? DEFAULT_LIMITS.maxCandidatesPerRoot,
-        maxSkillsLoadedPerSource: input?.maxSkillsLoadedPerSource ?? DEFAULT_LIMITS.maxSkillsLoadedPerSource,
-        maxSkillsInPrompt: input?.maxSkillsInPrompt ?? DEFAULT_LIMITS.maxSkillsInPrompt,
-        maxSkillsPromptChars: input?.maxSkillsPromptChars ?? DEFAULT_LIMITS.maxSkillsPromptChars,
-        maxSkillFileBytes: input?.maxSkillFileBytes ?? DEFAULT_LIMITS.maxSkillFileBytes,
-    };
-}
-// ---------------------------------------------------------------------------
-// Path containment guard
-// ---------------------------------------------------------------------------
-function isPathInside(parentRealPath, childRealPath, sep) {
-    const normalizedParent = parentRealPath.endsWith(sep) ? parentRealPath : parentRealPath + sep;
-    return childRealPath === parentRealPath || childRealPath.startsWith(normalizedParent);
-}
-function resolveContainedPath(deps, rootRealPath, candidatePath) {
-    try {
-        const real = deps.fs.realpathSync(candidatePath);
-        return isPathInside(rootRealPath, real, deps.path.sep) ? real : null;
-    }
-    catch {
-        return null;
-    }
-}
-// ---------------------------------------------------------------------------
-// Directory listing helpers
-// ---------------------------------------------------------------------------
-function listChildDirectories(deps, dir) {
-    try {
-        const entries = deps.fs.readdirSync(dir, { withFileTypes: true });
-        const dirs = [];
-        for (const entry of entries) {
-            if (entry.name.startsWith(".") || entry.name === "node_modules")
-                continue;
-            if (entry.isDirectory()) {
-                dirs.push(entry.name);
-                continue;
-            }
-            if (entry.isSymbolicLink()) {
-                try {
-                    const fullPath = deps.path.join(dir, entry.name);
-                    if (deps.fs.statSync(fullPath).isDirectory()) {
-                        dirs.push(entry.name);
-                    }
-                }
-                catch {
-                    // broken symlink — skip
-                }
-            }
-        }
-        return dirs;
-    }
-    catch {
-        return [];
-    }
-}
-/**
- * Detect nested `skills/` subfolder. If `dir/skills/<x>/SKILL.md` exists,
- * treat `dir/skills/` as the real root.
- */
-function resolveNestedSkillsRoot(deps, dir, maxEntriesToScan) {
-    const nested = deps.path.join(dir, "skills");
-    try {
-        if (!deps.fs.existsSync(nested) || !deps.fs.statSync(nested).isDirectory()) {
-            return dir;
-        }
-    }
-    catch {
-        return dir;
-    }
-    const nestedDirs = listChildDirectories(deps, nested);
-    const toScan = nestedDirs.slice(0, Math.min(nestedDirs.length, maxEntriesToScan));
-    for (const name of toScan) {
-        const skillMd = deps.path.join(nested, name, "SKILL.md");
-        if (deps.fs.existsSync(skillMd)) {
-            return nested;
-        }
-    }
-    return dir;
-}
-// ---------------------------------------------------------------------------
-// Single-source skill loading
-// ---------------------------------------------------------------------------
-function loadSkillsFromSourceDir(deps, dir, source, limits) {
-    const rootDir = deps.path.resolve(dir);
-    let rootRealPath;
-    try {
-        rootRealPath = deps.fs.realpathSync(rootDir);
-    }
-    catch {
-        return [];
-    }
-    const baseDir = resolveNestedSkillsRoot(deps, rootDir, limits.maxCandidatesPerRoot);
-    const baseDirRealPath = resolveContainedPath(deps, rootRealPath, baseDir);
-    if (!baseDirRealPath)
-        return [];
-    // Case 1: root itself is a single skill
-    const rootSkillMd = deps.path.join(baseDir, "SKILL.md");
-    if (deps.fs.existsSync(rootSkillMd)) {
-        if (!resolveContainedPath(deps, baseDirRealPath, rootSkillMd))
-            return [];
-        try {
-            const size = deps.fs.statSync(rootSkillMd).size;
-            if (size > limits.maxSkillFileBytes)
-                return [];
-        }
-        catch {
-            return [];
-        }
-        return [buildWorkspaceSkill(deps, rootSkillMd, baseDir, source)].filter((s) => s !== null);
-    }
-    // Case 2: enumerate child directories for `<child>/SKILL.md`
-    const childDirs = listChildDirectories(deps, baseDir);
-    const maxCandidates = Math.max(0, limits.maxSkillsLoadedPerSource);
-    const limitedChildren = childDirs.slice().sort().slice(0, maxCandidates);
-    const skills = [];
-    for (const name of limitedChildren) {
-        const skillDir = deps.path.join(baseDir, name);
-        if (!resolveContainedPath(deps, baseDirRealPath, skillDir))
-            continue;
-        const skillMd = deps.path.join(skillDir, "SKILL.md");
-        if (!deps.fs.existsSync(skillMd))
-            continue;
-        if (!resolveContainedPath(deps, baseDirRealPath, skillMd))
-            continue;
-        try {
-            const size = deps.fs.statSync(skillMd).size;
-            if (size > limits.maxSkillFileBytes)
-                continue;
-        }
-        catch {
-            continue;
-        }
-        const skill = buildWorkspaceSkill(deps, skillMd, skillDir, source);
-        if (skill)
-            skills.push(skill);
-        if (skills.length >= limits.maxSkillsLoadedPerSource)
-            break;
-    }
-    return skills;
-}
-function buildWorkspaceSkill(deps, filePath, baseDir, source) {
-    try {
-        const content = deps.fs.readFileSync(filePath, "utf-8");
-        const fm = parseFrontmatter(content);
-        const name = fm["name"] ?? deps.path.resolve(baseDir).split(deps.path.sep).pop() ?? "unknown";
-        return {
-            name,
-            description: fm["description"],
-            source,
-            filePath: deps.path.resolve(filePath),
-            baseDir: deps.path.resolve(baseDir),
-            primaryEnv: fm["primaryEnv"] ?? fm["primary-env"],
-            requiredEnv: fm["required-env"]?.split(",").map((s) => s.trim()).filter(Boolean),
-        };
-    }
-    catch {
-        return null;
-    }
-}
-// ---------------------------------------------------------------------------
-// Public API
-// ---------------------------------------------------------------------------
-/**
- * Discover all skills from configured search paths, applying precedence merge
- * and size/count limits. Returns fully parsed `SkillEntry` objects.
- */
-export function loadSkillEntries(deps) {
-    const limits = resolveLimits(deps.limits);
-    const { searchPaths } = deps;
-    const sources = [];
-    // Order: extra < bundled < managed < personalAgents < projectAgents < workspace
-    if (searchPaths.extra) {
-        for (const dir of searchPaths.extra) {
-            sources.push({ dir, source: "extra" });
-        }
-    }
-    if (searchPaths.bundled) {
-        sources.push({ dir: searchPaths.bundled, source: "bundled" });
-    }
-    if (searchPaths.managed) {
-        sources.push({ dir: searchPaths.managed, source: "managed" });
-    }
-    if (searchPaths.personalAgents) {
-        sources.push({ dir: searchPaths.personalAgents, source: "agents-personal" });
-    }
-    if (searchPaths.projectAgents) {
-        sources.push({ dir: searchPaths.projectAgents, source: "agents-project" });
-    }
-    if (searchPaths.workspace) {
-        sources.push({ dir: searchPaths.workspace, source: "workspace" });
-    }
-    // Merge with later sources overriding earlier ones (by name)
-    const merged = new Map();
-    for (const src of sources) {
-        const skills = loadSkillsFromSourceDir(deps, src.dir, src.source, limits);
-        for (const skill of skills) {
-            merged.set(skill.name, skill);
-        }
-    }
-    // Build entries with parsed metadata
-    const entries = [];
-    for (const skill of merged.values()) {
-        let frontmatter = parseFrontmatter("");
-        try {
-            const raw = deps.fs.readFileSync(skill.filePath, "utf-8");
-            frontmatter = parseFrontmatter(raw);
-        }
-        catch {
-            // ignore malformed
-        }
-        entries.push({
-            skill,
-            frontmatter,
-            metadata: resolveSkillMetadata(frontmatter),
-            invocation: resolveSkillInvocationPolicy(frontmatter),
-        });
-    }
-    return entries;
-}
-/**
- * Filter skill entries by a name-based filter list.
- * If filter is undefined or empty, returns all entries.
- */
-export function filterSkillEntries(entries, skillFilter) {
-    if (!skillFilter || skillFilter.length === 0)
-        return entries;
-    const normalized = new Set(skillFilter.map((s) => s.trim().toLowerCase()).filter(Boolean));
-    if (normalized.size === 0)
-        return [];
-    return entries.filter((e) => normalized.has(e.skill.name.toLowerCase()));
-}
-/**
- * Build a system-prompt-embeddable skill snapshot.
- * Applies count and character limits from the provided config.
- */
-export function buildSkillSnapshot(entries, limits, skillFilter) {
-    const resolved = resolveLimits(limits);
-    const filtered = filterSkillEntries(entries, skillFilter);
-    // Truncate by count first
-    let promptSkills = filtered.slice(0, Math.max(0, resolved.maxSkillsInPrompt));
-    // Format function for prompt
-    const formatForPrompt = (skills) => {
-        if (skills.length === 0)
-            return "";
-        const lines = [];
-        for (const entry of skills) {
-            const s = entry.skill;
-            const meta = entry.metadata;
-            const desc = s.description ? ` — ${s.description}` : "";
-            const env = s.primaryEnv ? ` [${s.primaryEnv}]` : "";
-            const emoji = meta?.emoji ? `${meta.emoji} ` : "";
-            lines.push(`- ${emoji}**${s.name}**${env}${desc}`);
-            // Compact path with ~ prefix
-            lines.push(`  File: ${s.filePath}`);
-        }
-        return lines.join("\n");
-    };
-    // Truncate by character budget via binary search
-    let prompt = formatForPrompt(promptSkills);
-    if (prompt.length > resolved.maxSkillsPromptChars) {
-        let lo = 0;
-        let hi = promptSkills.length;
-        while (lo < hi) {
-            const mid = Math.ceil((lo + hi) / 2);
-            const candidate = formatForPrompt(promptSkills.slice(0, mid));
-            if (candidate.length <= resolved.maxSkillsPromptChars) {
-                lo = mid;
-            }
-            else {
-                hi = mid - 1;
-            }
-        }
-        promptSkills = promptSkills.slice(0, lo);
-        prompt = formatForPrompt(promptSkills);
-    }
-    return {
-        prompt,
-        skills: promptSkills.map((e) => ({
-            name: e.skill.name,
-            primaryEnv: e.skill.primaryEnv,
-            requiredEnv: e.skill.requiredEnv,
-        })),
-        skillFilter,
-    };
-}

package/dist/skills/skill-source.js

@@ -1,126 +0,0 @@
-// ---------------------------------------------------------------------------
-// Skill source abstraction — defines where skills come from and how they
-// are fetched/installed. Consumers implement specific source adapters.
-// ---------------------------------------------------------------------------
-/**
- * Orchestrate the full install pipeline:
- * Fetch → Quarantine → Scan → Validate → Move → Lock
- *
- * This function is pure orchestration — actual I/O is delegated to deps.
- */
-export async function installSkill(params) {
-    const { source, fetchDeps, storageDeps, scanSkillDir, quarantineDir } = params;
-    // Step 1: Fetch to quarantine
-    let fetchResult;
-    try {
-        fetchResult = await fetchDeps.fetch(source, quarantineDir);
-    }
-    catch (err) {
-        return {
-            success: false,
-            name: source.identifier,
-            verdict: "reject",
-            error: `Fetch failed: ${err instanceof Error ? err.message : String(err)}`,
-        };
-    }
-    const skillName = fetchResult.name ?? source.identifier.split("/").pop() ?? "unknown";
-    // Step 2: Security scan
-    let scanSummary;
-    try {
-        scanSummary = await scanSkillDir(fetchResult.quarantineDir);
-    }
-    catch (err) {
-        return {
-            success: false,
-            name: skillName,
-            verdict: "reject",
-            error: `Scan failed: ${err instanceof Error ? err.message : String(err)}`,
-        };
-    }
-    // Step 3: Verdict
-    let verdict;
-    if (scanSummary.critical > 0) {
-        verdict = source.trust === "builtin" ? "quarantine" : "reject";
-    }
-    else if (scanSummary.warn > 0) {
-        verdict = "quarantine";
-    }
-    else {
-        verdict = "pass";
-    }
-    if (verdict === "reject") {
-        return {
-            success: false,
-            name: skillName,
-            verdict,
-            scanSummary,
-            error: `Security scan rejected: ${scanSummary.critical} critical finding(s)`,
-        };
-    }
-    // Step 4: Move to install location
-    let installDir;
-    try {
-        installDir = await storageDeps.moveToInstallDir(fetchResult.quarantineDir, skillName);
-    }
-    catch (err) {
-        return {
-            success: false,
-            name: skillName,
-            verdict,
-            scanSummary,
-            error: `Install move failed: ${err instanceof Error ? err.message : String(err)}`,
-        };
-    }
-    // Step 5: Update lockfile
-    try {
-        const lockfile = await storageDeps.readLockfile();
-        lockfile.entries[skillName] = {
-            name: skillName,
-            source,
-            installedAt: new Date().toISOString(),
-            scanVerdict: verdict,
-            scanSummary,
-        };
-        await storageDeps.writeLockfile(lockfile);
-    }
-    catch {
-        // Non-fatal: skill is installed but lock may be stale
-    }
-    return {
-        success: true,
-        name: skillName,
-        installDir,
-        verdict,
-        scanSummary,
-    };
-}
-/**
- * Uninstall a skill: remove from disk + update lockfile.
- */
-export async function uninstallSkill(params) {
-    const { skillName, storageDeps } = params;
-    try {
-        await storageDeps.removeSkill(skillName);
-    }
-    catch (err) {
-        return {
-            success: false,
-            error: `Remove failed: ${err instanceof Error ? err.message : String(err)}`,
-        };
-    }
-    try {
-        const lockfile = await storageDeps.readLockfile();
-        delete lockfile.entries[skillName];
-        await storageDeps.writeLockfile(lockfile);
-    }
-    catch {
-        // Non-fatal
-    }
-    return { success: true };
-}
-/**
- * Create an empty lockfile.
- */
-export function createEmptyLockfile() {
-    return { version: 1, entries: {} };
-}

package/dist/skills/skill-types.js

@@ -1,6 +0,0 @@
-// ---------------------------------------------------------------------------
-// Skill system type definitions — portable, runtime-agnostic.
-// Mirrors openclaw/src/agents/skills/types.ts + security/skill-scanner.ts
-// but decoupled from framework internals.
-// ---------------------------------------------------------------------------
-export {};

package/dist/skills/think-tool.js

@@ -1,59 +0,0 @@
-// ============================================================
-// Think Tool — explicit reasoning before complex decisions.
-//
-// The Agent calls `think` to reason step-by-step before deciding
-// which tools to use. The thought is never shown to the user.
-// Pure no-op: zero side effects, zero dependencies.
-// ============================================================
-export const THINK_TOOL_NAME = "think";
-export const THINK_TOOL_SCHEMA = {
-    type: "object",
-    properties: {
-        thought: {
-            type: "string",
-            description: [
-                "Your internal reasoning about the current situation.",
-                "Use this to:",
-                "• Analyze what the user really wants (disambiguate vague requests)",
-                "• Plan multi-step approaches before executing",
-                "• Evaluate which tool(s) to use and why",
-                "• Consider edge cases or potential issues",
-                "• Reflect on conversation context and user preferences",
-                "This content is never shown to the user.",
-            ].join("\n"),
-        },
-    },
-    required: ["thought"],
-};
-export function createThinkTool() {
-    return {
-        name: THINK_TOOL_NAME,
-        label: "Think",
-        shouldDefer: true,
-        description: [
-            "Use this tool to think and reason about the current situation BEFORE taking action.",
-            "Call this tool when you need to:",
-            "- Analyze an ambiguous or complex user request before deciding what to do",
-            "- Plan a multi-step approach (what tools to call and in what order)",
-            "- Identify which steps can run in parallel vs. which must be sequential",
-            "- Evaluate tradeoffs between different approaches",
-            "- Reflect on user preferences from conversation history",
-            "- Process new information that changes your understanding",
-            "",
-            "This tool has NO side effects — it simply records your reasoning process.",
-            "Your thought is NOT shown to the user; it only improves YOUR decision quality.",
-            "After thinking, proceed to take the appropriate action.",
-            "",
-            "When planning multi-step work, be explicit about parallelism:",
-            '- Say "这些可以并行生成" or "these can run in parallel" for independent tasks.',
-            '- Say "先…然后…" or "step 1 first, then step 2" for sequential dependencies.',
-        ].join("\n"),
-        parameters: THINK_TOOL_SCHEMA,
-        execute: async (_toolCallId, _params) => {
-            return {
-                content: [{ type: "text", text: "Thought recorded. Now proceed with the best action based on your reasoning." }],
-                details: { type: "think" },
-            };
-        },
-    };
-}

package/dist/skills/todo-tool.js

@@ -1,114 +0,0 @@
-// ============================================================
-// Todo Tool — session-level structured task management.
-//
-// Allows the agent to create, update, and track multi-step task
-// lists during complex conversations. Each tool invocation
-// replaces the full todo list (same pattern as Copilot's
-// manage_todo_list).
-//
-// Aligned with Claude Code TodoWriteTool:
-// - activeForm field (present-tense text for UI spinners)
-// - oldTodos snapshot returned for diffing
-// - Auto-clear when all items completed
-// - verificationNudgeNeeded signal
-// - Per-agent isolation via agentId option
-//
-// Reference: claude-code-haha/src/tools/TodoWriteTool/TodoWriteTool.ts
-// ============================================================
-import { summarizeTodoList } from "../contracts/todo.js";
-export const TODO_TOOL_NAME = "todo";
-export const TODO_TOOL_SCHEMA = {
-    type: "object",
-    properties: {
-        todoList: {
-            type: "array",
-            description: "Complete array of ALL todo items. Must include both existing and new items. " +
-                "Only one item may be in-progress at a time. Mark todos completed " +
-                "IMMEDIATELY after finishing — do not batch completions.",
-            items: {
-                type: "object",
-                properties: {
-                    id: { type: "number", description: "Unique numeric id (sequential from 1)." },
-                    title: { type: "string", description: "Concise action-oriented label (3-7 words). Displayed in UI." },
-                    status: {
-                        type: "string",
-                        enum: ["not-started", "in-progress", "completed"],
-                        description: "not-started | in-progress (max 1) | completed",
-                    },
-                },
-                required: ["id", "title", "status"],
-            },
-        },
-    },
-    required: ["todoList"],
-};
-/**
- * Create a stateful todo tool instance.
- *
- * Each call returns a tool with its own session-local list.
- * Multiple instances can exist for different sessions/agents.
- */
-export function createTodoTool(options) {
-    let currentList = [];
-    const opts = options ?? {};
-    return {
-        name: TODO_TOOL_NAME,
-        label: "Todo",
-        description: "Manage a structured todo list to track progress on multi-step tasks. " +
-            "Each call replaces the full list. Use frequently during complex work " +
-            "to plan steps and show progress. Mark items in-progress before starting, " +
-            "completed immediately after finishing.",
-        parameters: TODO_TOOL_SCHEMA,
-        searchHint: "manage session task checklist progress tracking",
-        maxResultSizeChars: 100_000,
-        execute: async (_toolCallId, params) => {
-            const items = params.todoList;
-            // Validate: at most 1 in-progress
-            const inProgress = items.filter((t) => t.status === "in-progress");
-            if (inProgress.length > 1) {
-                return {
-                    content: [{ type: "text", text: JSON.stringify({
-                                warning: `Only 1 item may be in-progress at a time (found ${inProgress.length}).`,
-                                todoList: currentList,
-                            }) }],
-                    details: { type: "todo", warning: "multiple_in_progress" },
-                };
-            }
-            // Capture old state for diff (CC-aligned: returns oldTodos)
-            const oldTodos = [...currentList];
-            // Check if all items are completed
-            const allDone = items.length > 0 && items.every((t) => t.status === "completed");
-            // Auto-clear when all completed (CC behavior)
-            if (allDone && opts.autoClearOnComplete) {
-                currentList = [];
-            }
-            else {
-                currentList = items;
-            }
-            const summary = summarizeTodoList(items);
-            // Verification nudge: ≥3 items, all done, none matching /verif/i
-            let verificationNudgeNeeded = false;
-            if (opts.enableVerificationNudge &&
-                allDone &&
-                items.length >= 3 &&
-                !items.some((t) => /verif/i.test(t.title))) {
-                verificationNudgeNeeded = true;
-            }
-            const result = {
-                total: summary.total,
-                completed: summary.completed,
-                inProgress: summary.inProgress,
-                notStarted: summary.notStarted,
-                todoList: currentList,
-                oldTodos,
-            };
-            if (verificationNudgeNeeded) {
-                result.verificationNudgeNeeded = true;
-            }
-            return {
-                content: [{ type: "text", text: JSON.stringify(result) }],
-                details: { type: "todo", ...summary, verificationNudgeNeeded, agentId: opts.agentId },
-            };
-        },
-    };
-}