langflower 0.1.0 → 0.1.2

package/vendor/tools/dist/domain/domain-tool-configs.js

@@ -1,299 +0,0 @@
-import { createCrawlContext } from '../create-crawl-context.js';
-import { createMemoryStore } from '../memory/create-memory-store.js';
-import { createWebFetch } from '../create-web-fetch.js';
-import { asNumber, asString, requireString } from './args.js';
-import { extractHtmlTitle, extractLinks, htmlToText } from './html.js';
-import { runBfsCrawl } from './run-bfs-crawl.js';
-const json = (value) => `${JSON.stringify(value, null, 2)}\n`;
-const requireWebFetch = (ctx) => ctx.webFetch ??
-    createWebFetch({
-        ...(ctx.allowedHosts !== undefined
-            ? { allowedHosts: ctx.allowedHosts }
-            : {}),
-    });
-const fetchPage = async (webFetch, url, timeoutMs, maxBytes) => {
-    const result = await webFetch({
-        url,
-        ...(timeoutMs !== undefined ? { timeoutMs } : {}),
-        ...(maxBytes !== undefined ? { maxBytes } : {}),
-    });
-    if (!result.ok) {
-        throw new Error(result.error ??
-            `Fetch failed for ${url} (status ${result.status}).`);
-    }
-    const text = htmlToText(result.body);
-    const title = extractHtmlTitle(result.body);
-    return {
-        url: result.url,
-        html: result.body,
-        text,
-        ...(title !== undefined ? { title } : {}),
-        status: result.status,
-    };
-};
-export const CRAWL_TOOL_CONFIGS = [
-    {
-        toolId: 'crawl_fetch',
-        description: 'HTTP GET a URL via SSRF-guarded fetch; returns status, title, and plain text.',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                url: { type: 'string', description: 'Absolute http(s) URL' },
-                timeoutMs: { type: 'number' },
-                maxBytes: { type: 'number' },
-            },
-            required: ['url'],
-        },
-        handler: async (args, ctx) => {
-            const page = await fetchPage(requireWebFetch(ctx), requireString(args, 'url'), asNumber(args, 'timeoutMs'), asNumber(args, 'maxBytes'));
-            return json({
-                url: page.url,
-                status: page.status,
-                title: page.title ?? null,
-                text: page.text,
-                htmlChars: page.html.length,
-            });
-        },
-    },
-    {
-        toolId: 'crawl_extract_links',
-        description: 'Extract absolute href links from HTML for a base URL.',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                html: { type: 'string' },
-                baseUrl: { type: 'string' },
-            },
-            required: ['html', 'baseUrl'],
-        },
-        handler: async (args) => {
-            const html = requireString(args, 'html');
-            const baseUrl = requireString(args, 'baseUrl');
-            const links = extractLinks(html, baseUrl);
-            return json({ count: links.length, links });
-        },
-    },
-    {
-        toolId: 'crawl_save_page',
-        description: 'Persist a crawled page under .langflower/crawl/{runId}/.',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                url: { type: 'string' },
-                html: { type: 'string' },
-                text: { type: 'string' },
-                title: { type: 'string' },
-            },
-            required: ['url'],
-        },
-        handler: async (args, ctx) => {
-            const url = requireString(args, 'url');
-            const html = asString(args, 'html') ?? '';
-            const text = asString(args, 'text') ?? htmlToText(html);
-            const title = asString(args, 'title');
-            const saved = await createCrawlContext(ctx.projectDir, ctx.runId).savePage({
-                url,
-                html,
-                text,
-                ...(title !== undefined && title.length > 0 ? { title } : {}),
-            });
-            return json(saved);
-        },
-    },
-    {
-        toolId: 'crawl_bfs',
-        description: 'Breadth-first crawl from a start URL (same-host by default); optionally saves pages.',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                url: { type: 'string' },
-                maxPages: { type: 'number', description: '1–50; default 5' },
-                maxDepth: {
-                    type: 'number',
-                    description: 'Optional link-expansion depth cap (0 = seed only). Omit for unlimited (default).',
-                },
-                sameHostOnly: { type: 'boolean', default: true },
-                save: { type: 'boolean', default: true },
-            },
-            required: ['url'],
-        },
-        handler: async (args, ctx) => {
-            const webFetch = requireWebFetch(ctx);
-            const crawl = createCrawlContext(ctx.projectDir, ctx.runId);
-            const startUrl = requireString(args, 'url');
-            const maxPages = Math.min(Math.max(1, Math.floor(asNumber(args, 'maxPages') ?? 5)), 50);
-            const maxDepthRaw = asNumber(args, 'maxDepth');
-            const maxDepth = maxDepthRaw === undefined
-                ? undefined
-                : Math.min(Math.max(0, Math.floor(maxDepthRaw)), 5);
-            const sameHostOnly = args.sameHostOnly !== false;
-            const save = args.save !== false;
-            const crawled = await runBfsCrawl({
-                startUrl,
-                maxPages,
-                sameHostOnly,
-                failureMode: 'record',
-                enqueueBudget: 'unlimited',
-                webFetch,
-                ...(maxDepth !== undefined ? { maxDepth } : {}),
-                ...(save ? { savePage: crawl.savePage } : {}),
-            });
-            const pages = crawled.map((page) => page.ok
-                ? {
-                    url: page.url,
-                    title: page.title ?? null,
-                    textChars: page.text.length,
-                }
-                : {
-                    url: page.url,
-                    error: page.error,
-                });
-            return json({
-                startUrl,
-                visited: pages.length,
-                pages,
-            });
-        },
-    },
-];
-export const MEMORY_TOOL_CONFIGS = [
-    {
-        toolId: 'get_memory_tree',
-        description: 'Returns the structure of the memory directory including file names and their top-level Markdown headings to understand where information is stored.',
-        inputSchema: {
-            type: 'object',
-            properties: {},
-            required: [],
-        },
-        handler: async (_args, ctx) => {
-            const tree = await createMemoryStore(ctx.projectDir).getTree();
-            return json({ root: '.langflower/memory', files: tree });
-        },
-    },
-    {
-        toolId: 'read_memory_section',
-        description: 'Reads the content of a memory file. Can optionally target a specific Markdown heading section.',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                file_path: {
-                    type: 'string',
-                    description: "Relative path to the file inside the memory folder, e.g., 'core/project_summary.md'",
-                },
-                heading: {
-                    type: 'string',
-                    description: "Optional Markdown heading (e.g., '## Architecture' or 'Database Schema'). If omitted, the entire file is returned.",
-                },
-            },
-            required: ['file_path'],
-        },
-        handler: async (args, ctx) => {
-            const filePath = requireString(args, 'file_path');
-            const heading = asString(args, 'heading')?.trim();
-            const content = await createMemoryStore(ctx.projectDir).readSection(filePath, heading !== undefined && heading.length > 0
-                ? heading
-                : undefined);
-            return json({ file_path: filePath, content });
-        },
-    },
-    {
-        toolId: 'search_memory_grep',
-        description: 'Performs a fast, deterministic regex/keyword search across all files in the memory directory. Returns matching lines with file paths.',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                query: {
-                    type: 'string',
-                    description: "The search term or regular expression pattern (e.g., 'auth-tokens' or '#todo').",
-                },
-            },
-            required: ['query'],
-        },
-        handler: async (args, ctx) => {
-            const query = requireString(args, 'query');
-            const hits = await createMemoryStore(ctx.projectDir).searchGrep(query);
-            return json({
-                query,
-                hits,
-                count: hits.length,
-            });
-        },
-    },
-    {
-        toolId: 'append_memory_log',
-        description: 'Appends a new text entry or bullet point strictly to the end of a memory file. Use this for logging events, history, or chronological notes.',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                file_path: {
-                    type: 'string',
-                    description: "Relative path to the file inside the memory folder, e.g., 'history/2026-07-daily.md'",
-                },
-                content: {
-                    type: 'string',
-                    description: "The text content to append. Include necessary Markdown formatting (e.g., '- New event description').",
-                },
-            },
-            required: ['file_path', 'content'],
-        },
-        handler: async (args, ctx) => {
-            const filePath = requireString(args, 'file_path');
-            const content = requireString(args, 'content');
-            await createMemoryStore(ctx.projectDir).appendLog(filePath, content);
-            return json({ file_path: filePath, ok: true });
-        },
-    },
-    {
-        toolId: 'update_memory_section',
-        description: 'Updates or creates a specific Markdown heading section with new content. Replaces the old section content entirely. Keeps the rest of the file untouched.',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                file_path: {
-                    type: 'string',
-                    description: "Relative path to the file inside the memory folder, e.g., 'core/project_summary.md'",
-                },
-                heading: {
-                    type: 'string',
-                    description: "The exact title of the Markdown section to update (e.g., '## Dependencies'). If it doesn't exist, it will be created.",
-                },
-                new_content: {
-                    type: 'string',
-                    description: 'The new markdown body for this section. Do not include the heading itself here, only the content beneath it.',
-                },
-            },
-            required: ['file_path', 'heading', 'new_content'],
-        },
-        handler: async (args, ctx) => {
-            const filePath = requireString(args, 'file_path');
-            const heading = requireString(args, 'heading');
-            const newContent = requireString(args, 'new_content');
-            await createMemoryStore(ctx.projectDir).updateSection(filePath, heading, newContent);
-            return json({ file_path: filePath, heading, ok: true });
-        },
-    },
-    {
-        toolId: 'create_memory_file',
-        description: 'Creates a new empty memory file or initializes it with basic top-level structure. Fails if the file already exists.',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                file_path: {
-                    type: 'string',
-                    description: "Relative path for the new file, e.g., 'context/feature_auth.md'",
-                },
-                initial_content: {
-                    type: 'string',
-                    description: 'Optional initial markdown template or description to write into the file.',
-                },
-            },
-            required: ['file_path'],
-        },
-        handler: async (args, ctx) => {
-            const filePath = requireString(args, 'file_path');
-            const initial = asString(args, 'initial_content');
-            await createMemoryStore(ctx.projectDir).createFile(filePath, initial);
-            return json({ file_path: filePath, ok: true });
-        },
-    },
-];

package/vendor/tools/dist/domain/html.d.ts

@@ -1,4 +0,0 @@
-export declare const htmlToText: (html: string) => string;
-export declare const extractHtmlTitle: (html: string) => string | undefined;
-export declare const extractLinks: (html: string, baseUrl: string) => readonly string[];
-export declare const isSameHost: (leftUrl: string, rightUrl: string) => boolean;

package/vendor/tools/dist/domain/html.js

@@ -1,68 +0,0 @@
-const BLOCK_TAGS = /<(script|style|noscript|svg|iframe)[^>]*>[\s\S]*?<\/\1>/gi;
-const TAG_PATTERN = /<[^>]+>/g;
-const WHITESPACE_PATTERN = /\s+/g;
-const ENTITY_MAP = {
-    amp: '&',
-    lt: '<',
-    gt: '>',
-    quot: '"',
-    apos: "'",
-    nbsp: ' ',
-};
-const decodeBasicEntities = (text) => text.replace(/&(#x?[0-9a-fA-F]+|\w+);/g, (match, entity) => {
-    if (entity.startsWith('#x')) {
-        const code = Number.parseInt(entity.slice(2), 16);
-        return Number.isFinite(code) ? String.fromCodePoint(code) : match;
-    }
-    if (entity.startsWith('#')) {
-        const code = Number.parseInt(entity.slice(1), 10);
-        return Number.isFinite(code) ? String.fromCodePoint(code) : match;
-    }
-    return ENTITY_MAP[entity] ?? match;
-});
-export const htmlToText = (html) => {
-    const withoutBlocks = html.replace(BLOCK_TAGS, ' ');
-    const withoutTags = withoutBlocks.replace(TAG_PATTERN, ' ');
-    const decoded = decodeBasicEntities(withoutTags);
-    return decoded.replace(WHITESPACE_PATTERN, ' ').trim();
-};
-export const extractHtmlTitle = (html) => {
-    const match = html.match(/<title[^>]*>([\s\S]*?)<\/title>/i);
-    const title = match?.[1] !== undefined ? htmlToText(match[1]) : '';
-    return title.length > 0 ? title : undefined;
-};
-const resolveLink = (baseUrl, href) => {
-    const trimmed = href.trim();
-    if (trimmed.length === 0 ||
-        trimmed.startsWith('#') ||
-        trimmed.startsWith('mailto:') ||
-        trimmed.startsWith('javascript:')) {
-        return null;
-    }
-    try {
-        return new URL(trimmed, baseUrl).toString();
-    }
-    catch {
-        return null;
-    }
-};
-export const extractLinks = (html, baseUrl) => {
-    const links = new Set();
-    const pattern = /\shref\s*=\s*(?:"([^"]*)"|'([^']*)'|([^\s>]+))/gi;
-    for (const match of html.matchAll(pattern)) {
-        const href = match[1] ?? match[2] ?? match[3] ?? '';
-        const resolved = resolveLink(baseUrl, href);
-        if (resolved !== null) {
-            links.add(resolved);
-        }
-    }
-    return [...links].sort((left, right) => left.localeCompare(right));
-};
-export const isSameHost = (leftUrl, rightUrl) => {
-    try {
-        return new URL(leftUrl).hostname === new URL(rightUrl).hostname;
-    }
-    catch {
-        return false;
-    }
-};

package/vendor/tools/dist/domain/run-bfs-crawl.d.ts

@@ -1,57 +0,0 @@
-import type { WebFetchRequest, WebFetchResult } from '../create-web-fetch.js';
-export type BfsCrawlSavePage = (page: {
-    readonly url: string;
-    readonly html: string;
-    readonly text: string;
-    readonly title?: string;
-}) => Promise<{
-    readonly savedPath: string;
-}>;
-/**
- * How failed fetches join the result list:
- * - `skip` — graph Crawl: empty `!ok` bodies omitted; `!ok` with body still
- *   processed; unexpected `webFetch` throws propagate.
- * - `record` — `crawl_bfs` tool: `!ok` or throw → `{ ok: false, error }`, continue.
- */
-export type BfsCrawlFailureMode = 'skip' | 'record';
-/**
- * Whether the frontier may grow past `maxPages`:
- * - `maxPages` — graph: stop enqueueing when `pages + queue` would exceed cap.
- * - `unlimited` — tool: enqueue freely; only processed pages hit `maxPages`.
- */
-export type BfsCrawlEnqueueBudget = 'maxPages' | 'unlimited';
-export type RunBfsCrawlOptions = {
-    readonly startUrl: string;
-    readonly maxPages: number;
-    /** Cap link expansion depth (`0` = seed only). Omit for no depth limit. */
-    readonly maxDepth?: number;
-    /** Default `true`. */
-    readonly sameHostOnly?: boolean;
-    readonly timeoutMs?: number;
-    readonly maxBytes?: number;
-    readonly webFetch: (request: WebFetchRequest) => Promise<WebFetchResult>;
-    readonly savePage?: BfsCrawlSavePage;
-    readonly failureMode: BfsCrawlFailureMode;
-    /** Default `maxPages`. */
-    readonly enqueueBudget?: BfsCrawlEnqueueBudget;
-};
-export type BfsCrawlPage = {
-    readonly ok: true;
-    readonly url: string;
-    readonly status: number;
-    readonly html: string;
-    readonly text: string;
-    readonly title?: string;
-    readonly savedPath?: string;
-    readonly depth: number;
-} | {
-    readonly ok: false;
-    readonly url: string;
-    readonly error: string;
-    readonly depth: number;
-};
-/**
- * Shared BFS crawl used by graph `common-crawl` and agent `crawl_bfs`.
- * Contracts differ via options — not forked algorithms.
- */
-export declare const runBfsCrawl: (options: RunBfsCrawlOptions) => Promise<readonly BfsCrawlPage[]>;

package/vendor/tools/dist/domain/run-bfs-crawl.js

@@ -1,112 +0,0 @@
-import { extractHtmlTitle, extractLinks, htmlToText, isSameHost, } from './html.js';
-const fetchErrorMessage = (url, fetched) => fetched.error ?? `Fetch failed for ${url} (status ${fetched.status}).`;
-/**
- * Shared BFS crawl used by graph `common-crawl` and agent `crawl_bfs`.
- * Contracts differ via options — not forked algorithms.
- */
-export const runBfsCrawl = async (options) => {
-    const sameHostOnly = options.sameHostOnly !== false;
-    const enqueueBudget = options.enqueueBudget ?? 'maxPages';
-    const visited = new Set();
-    const scheduled = new Set([options.startUrl]);
-    const queue = [{ url: options.startUrl, depth: 0 }];
-    const pages = [];
-    const mayEnqueue = () => {
-        if (enqueueBudget === 'unlimited') {
-            return true;
-        }
-        return pages.length + queue.length < options.maxPages;
-    };
-    while (queue.length > 0 && pages.length < options.maxPages) {
-        const next = queue.shift();
-        if (next === undefined) {
-            break;
-        }
-        if (visited.has(next.url)) {
-            continue;
-        }
-        visited.add(next.url);
-        let fetched;
-        try {
-            fetched = await options.webFetch({
-                url: next.url,
-                ...(options.timeoutMs !== undefined
-                    ? { timeoutMs: options.timeoutMs }
-                    : {}),
-                ...(options.maxBytes !== undefined
-                    ? { maxBytes: options.maxBytes }
-                    : {}),
-            });
-        }
-        catch (error) {
-            if (options.failureMode === 'skip') {
-                throw error;
-            }
-            pages.push({
-                ok: false,
-                url: next.url,
-                error: error instanceof Error ? error.message : String(error),
-                depth: next.depth,
-            });
-            continue;
-        }
-        if (!fetched.ok) {
-            if (options.failureMode === 'record') {
-                pages.push({
-                    ok: false,
-                    url: next.url,
-                    error: fetchErrorMessage(next.url, fetched),
-                    depth: next.depth,
-                });
-                continue;
-            }
-            if (fetched.body.length === 0) {
-                continue;
-            }
-        }
-        const text = htmlToText(fetched.body);
-        const title = extractHtmlTitle(fetched.body);
-        const pageUrl = fetched.url || next.url;
-        let savedPath;
-        if (options.savePage !== undefined) {
-            const saved = await options.savePage({
-                url: pageUrl,
-                html: fetched.body,
-                text,
-                ...(title !== undefined ? { title } : {}),
-            });
-            savedPath = saved.savedPath;
-        }
-        pages.push({
-            ok: true,
-            url: pageUrl,
-            status: fetched.status,
-            html: fetched.body,
-            text,
-            depth: next.depth,
-            ...(title !== undefined ? { title } : {}),
-            ...(savedPath !== undefined ? { savedPath } : {}),
-        });
-        if (options.maxDepth !== undefined && next.depth >= options.maxDepth) {
-            continue;
-        }
-        const links = extractLinks(fetched.body, pageUrl);
-        const candidates = links.filter((link) => {
-            if (scheduled.has(link)) {
-                return false;
-            }
-            if (sameHostOnly && !isSameHost(options.startUrl, link)) {
-                return false;
-            }
-            return true;
-        });
-        for (const link of candidates) {
-            if (!mayEnqueue()) {
-                break;
-            }
-            scheduled.add(link);
-            queue.push({ url: link, depth: next.depth + 1 });
-        }
-    }
-    return pages;
-};

package/vendor/tools/dist/gate-tool-call.d.ts

@@ -1,17 +0,0 @@
-import type { ToolInvokeResult } from './harness-types.js';
-import { type PermissionAskRequest, type PermissionConfig, type PermissionDecision } from './permission.js';
-export type GateToolCallOptions = {
-    readonly toolId: string;
-    readonly detail: string;
-    readonly grants: Set<string>;
-    readonly permission: PermissionConfig;
-    readonly requestPermission?: (request: PermissionAskRequest) => Promise<PermissionDecision>;
-    /**
-     * When the tool id has no entry in `permission`, use this decision
-     * instead of {@link resolvePermission} (MCP tools → `'ask'`).
-     */
-    readonly whenMissingToolConfig?: PermissionDecision;
-};
-export declare const deniedToolResult: (toolId: string, detail: string) => ToolInvokeResult;
-/** Shared ask/grant/deny sequencing for project harness + MCP runtime. */
-export declare const gateToolCall: (options: GateToolCallOptions) => Promise<"allow" | "deny">;

package/vendor/tools/dist/gate-tool-call.js

@@ -1,35 +0,0 @@
-import { formatPermissionDeniedText, grantKeyForCall, permissionAskSummary, resolvePermission, } from './permission.js';
-export const deniedToolResult = (toolId, detail) => ({
-    ok: false,
-    text: formatPermissionDeniedText(toolId, detail),
-});
-/** Shared ask/grant/deny sequencing for project harness + MCP runtime. */
-export const gateToolCall = async (options) => {
-    const { toolId, detail, grants, permission, requestPermission, whenMissingToolConfig, } = options;
-    const key = grantKeyForCall(toolId, detail);
-    if (grants.has(key)) {
-        return 'allow';
-    }
-    const decision = whenMissingToolConfig !== undefined && permission[toolId] === undefined
-        ? whenMissingToolConfig
-        : resolvePermission(permission, toolId, detail);
-    if (decision === 'allow') {
-        return 'allow';
-    }
-    if (decision === 'deny') {
-        return 'deny';
-    }
-    if (requestPermission === undefined) {
-        return 'deny';
-    }
-    const reply = await requestPermission({
-        toolId,
-        detail,
-        summary: permissionAskSummary(toolId, detail),
-    });
-    if (reply === 'allow') {
-        grants.add(key);
-        return 'allow';
-    }
-    return 'deny';
-};

package/vendor/tools/dist/gitignore.d.ts

@@ -1,4 +0,0 @@
-export type GitIgnoreMatcher = {
-    readonly ignores: (relativePosix: string, isDirectory: boolean) => boolean;
-};
-export declare const loadGitIgnoreMatcher: (projectRoot: string) => Promise<GitIgnoreMatcher>;