mcpmake 0.1.1 → 0.2.1

package/dist/rescan/diff-engine.js

@@ -1,312 +0,0 @@
-/**
- * Compare two SiteDescriptors and produce a structured diff of changes.
- */
-export function diffSiteDescriptors(oldSite, newSite) {
-    const changes = [];
-    const brokenSelectors = [];
-    const now = new Date().toISOString();
-    const oldPagesByUrl = new Map(oldSite.pages.map((p) => [p.url, p]));
-    const newPagesByUrl = new Map(newSite.pages.map((p) => [p.url, p]));
-    // Detect added pages
-    for (const [url, page] of newPagesByUrl) {
-        if (!oldPagesByUrl.has(url)) {
-            changes.push({
-                changeType: 'added',
-                elementType: 'page',
-                elementId: page.pageId,
-                pageId: page.pageId,
-                description: `Page added: ${url}`,
-                timestamp: now,
-                newValue: url,
-            });
-        }
-    }
-    // Detect removed pages
-    for (const [url, page] of oldPagesByUrl) {
-        if (!newPagesByUrl.has(url)) {
-            changes.push({
-                changeType: 'removed',
-                elementType: 'page',
-                elementId: page.pageId,
-                pageId: page.pageId,
-                description: `Page removed: ${url}`,
-                timestamp: now,
-                oldValue: url,
-            });
-        }
-    }
-    // Compare matching pages
-    for (const [url, oldPage] of oldPagesByUrl) {
-        const newPage = newPagesByUrl.get(url);
-        if (!newPage)
-            continue;
-        diffForms(oldPage, newPage, changes, brokenSelectors, now);
-        diffButtons(oldPage, newPage, changes, brokenSelectors, now);
-        diffLinks(oldPage, newPage, changes, brokenSelectors, now);
-    }
-    const newVersion = oldSite.version + 1;
-    const updatedSite = {
-        ...newSite,
-        version: newVersion,
-    };
-    return {
-        previousVersion: oldSite.version,
-        newVersion,
-        changes,
-        brokenSelectors,
-        newSiteDescriptor: updatedSite,
-        timestamp: now,
-    };
-}
-function diffForms(oldPage, newPage, changes, brokenSelectors, timestamp) {
-    const oldFormsById = new Map(oldPage.forms.map((f) => [f.formId, f]));
-    const newFormsById = new Map(newPage.forms.map((f) => [f.formId, f]));
-    for (const [id, form] of newFormsById) {
-        if (!oldFormsById.has(id)) {
-            changes.push({
-                changeType: 'added',
-                elementType: 'form',
-                elementId: id,
-                pageId: newPage.pageId,
-                description: `Form added: ${form.semanticName ?? id}`,
-                timestamp,
-                newValue: form.semanticName,
-            });
-        }
-    }
-    for (const [id, form] of oldFormsById) {
-        if (!newFormsById.has(id)) {
-            changes.push({
-                changeType: 'removed',
-                elementType: 'form',
-                elementId: id,
-                pageId: oldPage.pageId,
-                description: `Form removed: ${form.semanticName ?? id}`,
-                timestamp,
-                oldValue: form.semanticName,
-            });
-        }
-    }
-    for (const [id, oldForm] of oldFormsById) {
-        const newForm = newFormsById.get(id);
-        if (!newForm)
-            continue;
-        // Check for field changes
-        diffFormFields(oldForm, newForm, oldPage.pageId, changes, timestamp);
-        // Check for broken selectors
-        if (oldForm.selector.primary !== newForm.selector.primary) {
-            if (newForm.selector.confidence < 0.5) {
-                brokenSelectors.push({
-                    toolName: newForm.semanticName ?? id,
-                    selector: oldForm.selector,
-                });
-                changes.push({
-                    changeType: 'selector-broken',
-                    elementType: 'form',
-                    elementId: id,
-                    pageId: oldPage.pageId,
-                    description: `Form selector changed with low confidence: ${oldForm.selector.primary}`,
-                    timestamp,
-                    oldValue: oldForm.selector.primary,
-                    newValue: newForm.selector.primary,
-                });
-            }
-            else {
-                changes.push({
-                    changeType: 'modified',
-                    elementType: 'form',
-                    elementId: id,
-                    pageId: oldPage.pageId,
-                    description: `Form selector updated: ${oldForm.selector.primary} → ${newForm.selector.primary}`,
-                    timestamp,
-                    oldValue: oldForm.selector.primary,
-                    newValue: newForm.selector.primary,
-                });
-            }
-        }
-    }
-}
-function diffFormFields(oldForm, newForm, pageId, changes, timestamp) {
-    const oldFieldsByName = new Map(oldForm.fields.map((f) => [f.name, f]));
-    const newFieldsByName = new Map(newForm.fields.map((f) => [f.name, f]));
-    for (const [name] of newFieldsByName) {
-        if (!oldFieldsByName.has(name)) {
-            changes.push({
-                changeType: 'added',
-                elementType: 'field',
-                elementId: `${oldForm.formId}:${name}`,
-                pageId,
-                description: `Field added to form ${oldForm.semanticName ?? oldForm.formId}: ${name}`,
-                timestamp,
-                newValue: name,
-            });
-        }
-    }
-    for (const [name] of oldFieldsByName) {
-        if (!newFieldsByName.has(name)) {
-            changes.push({
-                changeType: 'removed',
-                elementType: 'field',
-                elementId: `${oldForm.formId}:${name}`,
-                pageId,
-                description: `Field removed from form ${oldForm.semanticName ?? oldForm.formId}: ${name}`,
-                timestamp,
-                oldValue: name,
-            });
-        }
-    }
-    for (const [name, oldField] of oldFieldsByName) {
-        const newField = newFieldsByName.get(name);
-        if (!newField)
-            continue;
-        if (oldField.fieldType !== newField.fieldType) {
-            changes.push({
-                changeType: 'modified',
-                elementType: 'field',
-                elementId: `${oldForm.formId}:${name}`,
-                pageId,
-                description: `Field type changed in ${oldForm.semanticName ?? oldForm.formId}: ${oldField.fieldType} → ${newField.fieldType}`,
-                timestamp,
-                oldValue: oldField.fieldType,
-                newValue: newField.fieldType,
-            });
-        }
-        if (oldField.required !== newField.required) {
-            changes.push({
-                changeType: 'modified',
-                elementType: 'field',
-                elementId: `${oldForm.formId}:${name}`,
-                pageId,
-                description: `Field required changed in ${oldForm.semanticName ?? oldForm.formId}: ${oldField.required} → ${newField.required}`,
-                timestamp,
-                oldValue: oldField.required,
-                newValue: newField.required,
-            });
-        }
-    }
-}
-function diffButtons(oldPage, newPage, changes, brokenSelectors, timestamp) {
-    const oldById = new Map(oldPage.buttons.map((b) => [b.buttonId, b]));
-    const newById = new Map(newPage.buttons.map((b) => [b.buttonId, b]));
-    for (const [id, btn] of newById) {
-        if (!oldById.has(id)) {
-            changes.push({
-                changeType: 'added',
-                elementType: 'button',
-                elementId: id,
-                pageId: newPage.pageId,
-                description: `Button added: ${btn.text ?? btn.semanticAction ?? id}`,
-                timestamp,
-                newValue: btn.text,
-            });
-        }
-    }
-    for (const [id, btn] of oldById) {
-        if (!newById.has(id)) {
-            changes.push({
-                changeType: 'removed',
-                elementType: 'button',
-                elementId: id,
-                pageId: oldPage.pageId,
-                description: `Button removed: ${btn.text ?? btn.semanticAction ?? id}`,
-                timestamp,
-                oldValue: btn.text,
-            });
-        }
-    }
-    for (const [id, oldBtn] of oldById) {
-        const newBtn = newById.get(id);
-        if (!newBtn)
-            continue;
-        if (oldBtn.text !== newBtn.text) {
-            changes.push({
-                changeType: 'modified',
-                elementType: 'button',
-                elementId: id,
-                pageId: oldPage.pageId,
-                description: `Button text changed: "${oldBtn.text}" → "${newBtn.text}"`,
-                timestamp,
-                oldValue: oldBtn.text,
-                newValue: newBtn.text,
-            });
-        }
-        checkBrokenSelector(oldBtn.selector, newBtn.selector, oldBtn.semanticAction ?? id, id, 'button', oldPage.pageId, changes, brokenSelectors, timestamp);
-    }
-}
-function diffLinks(oldPage, newPage, changes, brokenSelectors, timestamp) {
-    const oldById = new Map(oldPage.links.map((l) => [l.linkId, l]));
-    const newById = new Map(newPage.links.map((l) => [l.linkId, l]));
-    for (const [id, link] of newById) {
-        if (!oldById.has(id)) {
-            changes.push({
-                changeType: 'added',
-                elementType: 'link',
-                elementId: id,
-                pageId: newPage.pageId,
-                description: `Link added: ${link.text ?? link.href}`,
-                timestamp,
-                newValue: link.href,
-            });
-        }
-    }
-    for (const [id, link] of oldById) {
-        if (!newById.has(id)) {
-            changes.push({
-                changeType: 'removed',
-                elementType: 'link',
-                elementId: id,
-                pageId: oldPage.pageId,
-                description: `Link removed: ${link.text ?? link.href}`,
-                timestamp,
-                oldValue: link.href,
-            });
-        }
-    }
-    for (const [id, oldLink] of oldById) {
-        const newLink = newById.get(id);
-        if (!newLink)
-            continue;
-        if (oldLink.href !== newLink.href) {
-            changes.push({
-                changeType: 'modified',
-                elementType: 'link',
-                elementId: id,
-                pageId: oldPage.pageId,
-                description: `Link href changed: "${oldLink.href}" → "${newLink.href}"`,
-                timestamp,
-                oldValue: oldLink.href,
-                newValue: newLink.href,
-            });
-        }
-        checkBrokenSelector(oldLink.selector, newLink.selector, oldLink.semanticAction ?? id, id, 'link', oldPage.pageId, changes, brokenSelectors, timestamp);
-    }
-}
-function checkBrokenSelector(oldSelector, newSelector, toolName, elementId, elementType, pageId, changes, brokenSelectors, timestamp) {
-    if (oldSelector.primary !== newSelector.primary) {
-        if (newSelector.confidence < 0.5) {
-            brokenSelectors.push({ toolName, selector: oldSelector });
-            changes.push({
-                changeType: 'selector-broken',
-                elementType,
-                elementId,
-                pageId,
-                description: `${elementType} selector changed with low confidence: ${oldSelector.primary}`,
-                timestamp,
-                oldValue: oldSelector.primary,
-                newValue: newSelector.primary,
-            });
-        }
-        else {
-            changes.push({
-                changeType: 'modified',
-                elementType,
-                elementId,
-                pageId,
-                description: `${elementType} selector updated: ${oldSelector.primary} → ${newSelector.primary}`,
-                timestamp,
-                oldValue: oldSelector.primary,
-                newValue: newSelector.primary,
-            });
-        }
-    }
-}

package/dist/rescan/index.d.ts

@@ -1,3 +0,0 @@
-export { diffSiteDescriptors } from './diff-engine.js';
-export { RescanScheduler, computeNextRun } from './rescan-scheduler.js';
-export type { ScheduleEntry, RescanCallback } from './rescan-scheduler.js';

package/dist/rescan/index.js

@@ -1,2 +0,0 @@
-export { diffSiteDescriptors } from './diff-engine.js';
-export { RescanScheduler, computeNextRun } from './rescan-scheduler.js';

package/dist/rescan/rescan-runner.d.ts

@@ -1,42 +0,0 @@
-/**
- * Pure helpers for the `mcpmake rescan` command: collecting fragile selectors
- * to heal and summarizing a diff. Kept free of Playwright/LLM/IO so they can be
- * unit-tested directly; the browser + LLM orchestration lives in the command.
- */
-import type { SiteDescriptor, SelectorSet, RescanResult } from '../types/site.js';
-/** A low-confidence selector flagged for healing, with a live object reference. */
-export interface LowConfidenceSelector {
-    /** URL of the page this selector lives on (for navigation during healing). */
-    pageUrl: string;
-    /** Human-readable description used in the heal prompt. */
-    description: string;
-    /**
-     * The actual SelectorSet object inside the descriptor. Mutating this (via
-     * Object.assign) updates the descriptor in place so regeneration picks up
-     * the healed selector.
-     */
-    selector: SelectorSet;
-}
-/**
- * Walk a SiteDescriptor and collect every selector whose confidence is below
- * `threshold` (default 0.5 — i.e. the brittle css-path / xpath fallbacks).
- */
-export declare function collectLowConfidenceSelectors(site: SiteDescriptor, threshold?: number): LowConfidenceSelector[];
-export interface ChangeCounts {
-    page: number;
-    form: number;
-    field: number;
-    button: number;
-    link: number;
-}
-export interface RescanSummary {
-    previousVersion: number;
-    newVersion: number;
-    added: ChangeCounts;
-    removed: ChangeCounts;
-    modified: ChangeCounts;
-    brokenSelectors: number;
-    totalChanges: number;
-}
-/** Summarize a RescanResult into per-kind change counts for reporting. */
-export declare function summarizeRescan(result: RescanResult): RescanSummary;

package/dist/rescan/rescan-runner.js

@@ -1,69 +0,0 @@
-/**
- * Pure helpers for the `mcpmake rescan` command: collecting fragile selectors
- * to heal and summarizing a diff. Kept free of Playwright/LLM/IO so they can be
- * unit-tested directly; the browser + LLM orchestration lives in the command.
- */
-/**
- * Walk a SiteDescriptor and collect every selector whose confidence is below
- * `threshold` (default 0.5 — i.e. the brittle css-path / xpath fallbacks).
- */
-export function collectLowConfidenceSelectors(site, threshold = 0.5) {
-    const out = [];
-    const consider = (selector, pageUrl, description) => {
-        if (selector && selector.confidence < threshold) {
-            out.push({ pageUrl, description, selector });
-        }
-    };
-    for (const page of site.pages) {
-        for (const form of page.forms) {
-            const formName = form.semanticName ?? form.formId;
-            consider(form.selector, page.url, `form "${formName}"`);
-            consider(form.submitButton, page.url, `submit button of form "${formName}"`);
-            for (const field of form.fields) {
-                consider(field.selector, page.url, `field "${field.name}" (${field.label ?? field.fieldType}) in form "${formName}"`);
-            }
-        }
-        for (const button of page.buttons) {
-            consider(button.selector, page.url, `button "${button.text ?? button.semanticAction ?? button.buttonId}"`);
-        }
-        for (const link of page.links) {
-            consider(link.selector, page.url, `link "${link.text ?? link.href}"`);
-        }
-    }
-    return out;
-}
-function emptyCounts() {
-    return { page: 0, form: 0, field: 0, button: 0, link: 0 };
-}
-/** Summarize a RescanResult into per-kind change counts for reporting. */
-export function summarizeRescan(result) {
-    const added = emptyCounts();
-    const removed = emptyCounts();
-    const modified = emptyCounts();
-    const bump = (counts, elementType) => {
-        counts[elementType] += 1;
-    };
-    for (const change of result.changes) {
-        switch (change.changeType) {
-            case 'added':
-                bump(added, change.elementType);
-                break;
-            case 'removed':
-                bump(removed, change.elementType);
-                break;
-            case 'modified':
-                bump(modified, change.elementType);
-                break;
-            // 'selector-broken' is reported separately via brokenSelectors.
-        }
-    }
-    return {
-        previousVersion: result.previousVersion,
-        newVersion: result.newVersion,
-        added,
-        removed,
-        modified,
-        brokenSelectors: result.brokenSelectors.length,
-        totalChanges: result.changes.length,
-    };
-}

package/dist/rescan/rescan-scheduler.d.ts

@@ -1,41 +0,0 @@
-export interface ScheduleEntry {
-    slug: string;
-    cronExpr: string;
-    partial: boolean;
-    nextRunAt: Date;
-    createdAt: Date;
-}
-export type RescanCallback = (slug: string, partial: boolean) => void | Promise<void>;
-/**
- * In-memory scheduler for periodic site rescans.
- * Checks every 60 seconds for due rescans and invokes the callback.
- */
-export declare class RescanScheduler {
-    private schedules;
-    private timer;
-    private callback;
-    private running;
-    constructor(callback: RescanCallback);
-    /** Register or update a rescan schedule for a site slug. */
-    scheduleRescan(slug: string, cronExpr: string, partial?: boolean): void;
-    /** Cancel a pending rescan schedule. */
-    cancelRescan(slug: string): boolean;
-    /** Start the periodic checker (every 60s). */
-    start(): void;
-    /** Stop the periodic checker. */
-    stop(): void;
-    /** Visible for testing: run a single check cycle. */
-    tick(): Promise<void>;
-    /** Get all registered schedules (for introspection / testing). */
-    getSchedules(): ReadonlyMap<string, ScheduleEntry>;
-}
-/**
- * Parse a simplified cron expression and compute the next run time after `after`.
- *
- * Supported format: "minute hour dayOfMonth month dayOfWeek"
- *   - Each field can be a number or '*'
- *   - Ranges (1-5), lists (1,3,5), and step values (*\/10) are supported for minute/hour
- *
- * Returns null if the expression is invalid.
- */
-export declare function computeNextRun(cronExpr: string, after: Date): Date | null;

package/dist/rescan/rescan-scheduler.js

@@ -1,179 +0,0 @@
-import { logger } from '../utils/logger.js';
-/**
- * In-memory scheduler for periodic site rescans.
- * Checks every 60 seconds for due rescans and invokes the callback.
- */
-export class RescanScheduler {
-    schedules = new Map();
-    timer = null;
-    callback;
-    running = false;
-    constructor(callback) {
-        this.callback = callback;
-    }
-    /** Register or update a rescan schedule for a site slug. */
-    scheduleRescan(slug, cronExpr, partial = false) {
-        const nextRunAt = computeNextRun(cronExpr, new Date());
-        if (!nextRunAt) {
-            logger.warn(`Invalid cron expression for slug "${slug}": ${cronExpr}`);
-            return;
-        }
-        this.schedules.set(slug, {
-            slug,
-            cronExpr,
-            partial,
-            nextRunAt,
-            createdAt: new Date(),
-        });
-        logger.info(`Scheduled rescan for "${slug}" — next run at ${nextRunAt.toISOString()}`);
-    }
-    /** Cancel a pending rescan schedule. */
-    cancelRescan(slug) {
-        const deleted = this.schedules.delete(slug);
-        if (deleted) {
-            logger.info(`Cancelled rescan schedule for "${slug}"`);
-        }
-        return deleted;
-    }
-    /** Start the periodic checker (every 60s). */
-    start() {
-        if (this.running)
-            return;
-        this.running = true;
-        this.timer = setInterval(() => {
-            void this.tick();
-        }, 60_000);
-        logger.info('Rescan scheduler started');
-    }
-    /** Stop the periodic checker. */
-    stop() {
-        if (!this.running)
-            return;
-        this.running = false;
-        if (this.timer !== null) {
-            clearInterval(this.timer);
-            this.timer = null;
-        }
-        logger.info('Rescan scheduler stopped');
-    }
-    /** Visible for testing: run a single check cycle. */
-    async tick() {
-        const now = new Date();
-        for (const entry of this.schedules.values()) {
-            if (entry.nextRunAt <= now) {
-                try {
-                    await this.callback(entry.slug, entry.partial);
-                }
-                catch (err) {
-                    logger.error(`Rescan callback failed for "${entry.slug}": ${err instanceof Error ? err.message : String(err)}`);
-                }
-                // Advance to the next scheduled run
-                const next = computeNextRun(entry.cronExpr, now);
-                if (next) {
-                    entry.nextRunAt = next;
-                }
-                else {
-                    // Invalid cron — remove the schedule
-                    this.schedules.delete(entry.slug);
-                }
-            }
-        }
-    }
-    /** Get all registered schedules (for introspection / testing). */
-    getSchedules() {
-        return this.schedules;
-    }
-}
-// ─── Simple Cron Parsing ──────────────────────────────────────────
-/**
- * Parse a simplified cron expression and compute the next run time after `after`.
- *
- * Supported format: "minute hour dayOfMonth month dayOfWeek"
- *   - Each field can be a number or '*'
- *   - Ranges (1-5), lists (1,3,5), and step values (*\/10) are supported for minute/hour
- *
- * Returns null if the expression is invalid.
- */
-export function computeNextRun(cronExpr, after) {
-    const parts = cronExpr.trim().split(/\s+/);
-    if (parts.length !== 5)
-        return null;
-    const minuteSpec = parts[0];
-    const hourSpec = parts[1];
-    const domSpec = parts[2];
-    const monthSpec = parts[3];
-    const dowSpec = parts[4];
-    const minutes = expandField(minuteSpec, 0, 59);
-    const hours = expandField(hourSpec, 0, 23);
-    const doms = expandField(domSpec, 1, 31);
-    const months = expandField(monthSpec, 1, 12);
-    const dows = expandField(dowSpec, 0, 6);
-    if (!minutes || !hours || !doms || !months || !dows)
-        return null;
-    // Brute-force search over the next 400 days to find the first matching time
-    const candidate = new Date(after.getTime());
-    candidate.setSeconds(0, 0);
-    candidate.setMinutes(candidate.getMinutes() + 1); // Start from the next minute
-    const limit = new Date(after.getTime() + 7 * 24 * 60 * 60 * 1000);
-    while (candidate < limit) {
-        const m = candidate.getMinutes();
-        const h = candidate.getHours();
-        const dom = candidate.getDate();
-        const mon = candidate.getMonth() + 1; // JS months are 0-based
-        const dow = candidate.getDay();
-        if (minutes.includes(m) &&
-            hours.includes(h) &&
-            doms.includes(dom) &&
-            months.includes(mon) &&
-            dows.includes(dow)) {
-            return candidate;
-        }
-        candidate.setMinutes(candidate.getMinutes() + 1);
-    }
-    return null;
-}
-function expandField(spec, min, max) {
-    if (spec === '*') {
-        return range(min, max);
-    }
-    // Step: */N
-    const stepMatch = spec.match(/^\*\/(\d+)$/);
-    if (stepMatch) {
-        const step = parseInt(stepMatch[1], 10);
-        if (step <= 0 || step > max)
-            return null;
-        const result = [];
-        for (let i = min; i <= max; i += step) {
-            result.push(i);
-        }
-        return result;
-    }
-    // List: 1,3,5
-    if (spec.includes(',')) {
-        const values = spec.split(',').map((s) => parseInt(s.trim(), 10));
-        if (values.some((v) => isNaN(v) || v < min || v > max))
-            return null;
-        return values;
-    }
-    // Range: 1-5
-    const rangeMatch = spec.match(/^(\d+)-(\d+)$/);
-    if (rangeMatch) {
-        const start = parseInt(rangeMatch[1], 10);
-        const end = parseInt(rangeMatch[2], 10);
-        if (start < min || end > max || start > end)
-            return null;
-        return range(start, end);
-    }
-    // Single number
-    const num = parseInt(spec, 10);
-    if (isNaN(num) || num < min || num > max)
-        return null;
-    return [num];
-}
-function range(start, end) {
-    const result = [];
-    for (let i = start; i <= end; i++) {
-        result.push(i);
-    }
-    return result;
-}

package/dist/site-transformer/browser-tools.d.ts

@@ -1,10 +0,0 @@
-/**
- * Built-in browser lifecycle tools that every generated site MCP server includes.
- * These are not derived from site analysis — they manage the Playwright browser.
- */
-import type { SiteToolDefinition } from '../types/site.js';
-/**
- * Returns the three built-in browser lifecycle tools:
- * start_browser, stop_browser, take_screenshot
- */
-export declare function buildBrowserLifecycleTools(): SiteToolDefinition[];