@mugwork/mug 0.1.0

package/dist/src/commands/form.d.ts

@@ -0,0 +1,8 @@
+export declare function formInit(name: string): void;
+export interface ValidationError {
+    file: string;
+    message: string;
+}
+export declare function formValidate(name?: string): void;
+export declare function validateFormConfigErrors(file: string, cfg: Record<string, unknown>): ValidationError[];
+export declare function formList(): void;

package/dist/src/commands/form.js

@@ -0,0 +1,396 @@
+import { existsSync, readFileSync, writeFileSync, readdirSync, mkdirSync } from "node:fs";
+import { join } from "node:path";
+function loadMugJson(dir) {
+    const path = join(dir, "mug.json");
+    if (!existsSync(path)) {
+        console.error("No mug.json found. Run `mug init` first.");
+        process.exit(1);
+    }
+    return JSON.parse(readFileSync(path, "utf-8"));
+}
+export function formInit(name) {
+    const dir = process.cwd();
+    loadMugJson(dir);
+    const surfacesDir = join(dir, "src", "surfaces");
+    if (!existsSync(surfacesDir)) {
+        mkdirSync(surfacesDir, { recursive: true });
+    }
+    const configPath = join(surfacesDir, `${name}.json`);
+    if (existsSync(configPath)) {
+        console.error(`Surface config already exists: src/surfaces/${name}.json`);
+        process.exit(1);
+    }
+    const handlerPath = join(dir, "src", "workflows", `handle-${name}.ts`);
+    if (existsSync(handlerPath)) {
+        console.error(`File already exists: src/workflows/handle-${name}.ts`);
+        process.exit(1);
+    }
+    const formConfig = {
+        type: "form",
+        title: titleCase(name),
+        description: "",
+        submitText: "Submit",
+        workflow: `handle-${name}`,
+        access: { mode: "public" },
+        fields: [
+            { name: "name", type: "text", label: "Name", required: true },
+            { name: "email", type: "email", label: "Email", required: true },
+            { name: "message", type: "textarea", label: "Message", rows: 4 },
+        ],
+    };
+    writeFileSync(configPath, JSON.stringify(formConfig, null, 2) + "\n");
+    console.log(`  [+] src/surfaces/${name}.json`);
+    const handlerWorkflow = `import { workflow } from "../workflow.js";
+
+workflow("handle-${name}", async (ctx) => {
+  const params = ctx.params as Record<string, string>;
+  const name = params.name;
+  const email = params._verified_email ?? params.email;
+
+  // TODO: process the submission
+  // await ctx.exec("main", "INSERT INTO ...", [...]);
+  // await ctx.notify.email({ to: "owner@example.com", subject: "New submission", message: "..." });
+
+  return { name, email, received: true };
+});
+`;
+    writeFileSync(handlerPath, handlerWorkflow);
+    console.log(`  [+] src/workflows/handle-${name}.ts`);
+    const indexPath = join(dir, "src", "index.ts");
+    if (existsSync(indexPath)) {
+        let index = readFileSync(indexPath, "utf-8");
+        const handlerImport = `import "./workflows/handle-${name}.js";`;
+        if (!index.includes(handlerImport)) {
+            index = addImport(index, handlerImport);
+        }
+        writeFileSync(indexPath, index);
+        console.log(`  [+] import wired in src/index.ts`);
+    }
+    console.log(`\nForm "${name}" ready. Edit the config to set your fields.`);
+    console.log(`  mug dev`);
+    console.log(`  open http://localhost:8787/${name}`);
+}
+function addImport(source, importLine) {
+    const marker = "// Import workflows here:";
+    const idx = source.indexOf(marker);
+    if (idx !== -1) {
+        const insertAt = idx + marker.length;
+        return source.slice(0, insertAt) + "\n" + importLine + source.slice(insertAt);
+    }
+    const lastImportMatch = source.match(/^import\s.+$/gm);
+    if (lastImportMatch) {
+        const lastImport = lastImportMatch[lastImportMatch.length - 1];
+        const lastIdx = source.lastIndexOf(lastImport);
+        const insertAt = lastIdx + lastImport.length;
+        return source.slice(0, insertAt) + "\n" + importLine + source.slice(insertAt);
+    }
+    return importLine + "\n" + source;
+}
+function titleCase(kebab) {
+    return kebab
+        .split("-")
+        .map((w) => w.charAt(0).toUpperCase() + w.slice(1))
+        .join(" ");
+}
+const VALID_FIELD_TYPES = new Set([
+    "text", "email", "phone", "number", "select", "multiselect",
+    "date", "textarea", "file", "calculated",
+]);
+const VALID_OPERATORS = new Set([
+    "eq", "neq", "in", "gt", "lt", "filled", "empty",
+]);
+const VALID_FORMATS = new Set(["number", "currency", "percent"]);
+const VALID_VALIDATION_RULES = new Set(["min", "max", "minLength", "maxLength", "pattern"]);
+export function formValidate(name) {
+    const dir = process.cwd();
+    loadMugJson(dir);
+    const errors = [];
+    let formsFound = 0;
+    const surfacesDir = join(dir, "src", "surfaces");
+    if (existsSync(surfacesDir)) {
+        const jsonFiles = name
+            ? [`${name}.json`]
+            : readdirSync(surfacesDir).filter((f) => f.endsWith(".json"));
+        for (const file of jsonFiles) {
+            const filePath = join(surfacesDir, file);
+            if (!existsSync(filePath))
+                continue;
+            try {
+                const cfg = JSON.parse(readFileSync(filePath, "utf-8"));
+                if (cfg.type === "portal")
+                    continue;
+                formsFound++;
+                validateCollectOptions(`src/surfaces/${file}`, cfg, errors);
+            }
+            catch {
+                errors.push({ file: `src/surfaces/${file}`, message: "Could not parse JSON" });
+            }
+        }
+    }
+    const workflowsDir = join(dir, "src", "workflows");
+    if (existsSync(workflowsDir)) {
+        const tsFiles = name
+            ? [`${name}.ts`]
+            : readdirSync(workflowsDir).filter((f) => f.endsWith(".ts"));
+        for (const file of tsFiles) {
+            const filePath = join(workflowsDir, file);
+            if (!existsSync(filePath))
+                continue;
+            const content = readFileSync(filePath, "utf-8");
+            if (!content.includes("ctx.collect(") && !content.includes("ctx.collect({"))
+                continue;
+            formsFound++;
+            const collectMatch = content.match(/ctx\.collect\(\s*\{/);
+            if (!collectMatch)
+                continue;
+            const startIdx = collectMatch.index + collectMatch[0].length - 1;
+            const block = extractObject(content, startIdx);
+            if (!block) {
+                errors.push({ file, message: "Could not parse ctx.collect() options" });
+                continue;
+            }
+            try {
+                const fn = new Function(`return (${block})`);
+                const opts = fn();
+                validateCollectOptions(file, opts, errors);
+            }
+            catch {
+                errors.push({ file, message: "Could not evaluate ctx.collect() options (dynamic expressions are skipped)" });
+            }
+        }
+    }
+    if (formsFound === 0) {
+        console.log("No forms found. Create one with: mug form init <name>");
+        return;
+    }
+    if (errors.length === 0) {
+        console.log(`  [+] ${formsFound} form${formsFound !== 1 ? "s" : ""} validated — no errors`);
+    }
+    else {
+        console.log(`  [x] ${errors.length} error${errors.length !== 1 ? "s" : ""} in ${formsFound} form${formsFound !== 1 ? "s" : ""}:\n`);
+        for (const err of errors) {
+            console.log(`  ${err.file}: ${err.message}`);
+        }
+        process.exit(1);
+    }
+}
+function validateCollectOptions(file, opts, errors) {
+    if (!opts.title) {
+        errors.push({ file, message: "Missing required field: title" });
+    }
+    if (!opts.workflow) {
+        errors.push({ file, message: "Missing required field: workflow" });
+    }
+    const pages = opts.pages ?? [];
+    const fields = opts.fields ?? [];
+    if (pages.length === 0 && fields.length === 0) {
+        errors.push({ file, message: "Must specify either pages or fields" });
+        return;
+    }
+    const pageIds = new Set();
+    const allFieldNames = new Set();
+    if (fields.length > 0) {
+        for (const field of fields) {
+            validateField(file, field, errors);
+            if (field.name) {
+                const n = field.name;
+                if (allFieldNames.has(n)) {
+                    errors.push({ file, message: `Duplicate field name: "${n}"` });
+                }
+                allFieldNames.add(n);
+            }
+        }
+    }
+    for (const page of pages) {
+        if (!page.id) {
+            errors.push({ file, message: "Page missing required field: id" });
+        }
+        else {
+            pageIds.add(page.id);
+        }
+        const pageFields = page.fields ?? [];
+        for (const field of pageFields) {
+            validateField(file, field, errors);
+            if (field.name) {
+                const n = field.name;
+                if (allFieldNames.has(n)) {
+                    errors.push({ file, message: `Duplicate field name: "${n}" (in page "${page.id ?? "?"}")` });
+                }
+                allFieldNames.add(n);
+            }
+        }
+    }
+    for (const page of pages) {
+        const nextPage = page.nextPage;
+        if (typeof nextPage === "string") {
+            if (!pageIds.has(nextPage)) {
+                errors.push({ file, message: `Page "${page.id}": nextPage references unknown page "${nextPage}"` });
+            }
+        }
+        else if (nextPage && typeof nextPage === "object") {
+            const np = nextPage;
+            const conditions = np.conditions ?? [];
+            for (const cond of conditions) {
+                if (cond.goto && !pageIds.has(cond.goto)) {
+                    errors.push({ file, message: `Page "${page.id}": nextPage.goto references unknown page "${cond.goto}"` });
+                }
+                validateConditions(file, `page "${page.id}" nextPage`, cond.when ?? [], errors);
+            }
+            if (np.default && !pageIds.has(np.default)) {
+                errors.push({ file, message: `Page "${page.id}": nextPage.default references unknown page "${np.default}"` });
+            }
+        }
+    }
+    if (opts.access && typeof opts.access === "object") {
+        const access = opts.access;
+        const mode = access.mode;
+        if (mode && !["public", "identify", "auth"].includes(mode)) {
+            errors.push({ file, message: `Invalid access mode: "${mode}" (must be public, identify, or auth)` });
+        }
+        if (mode === "identify" || mode === "auth") {
+            if (!access.method || !["email", "phone"].includes(access.method)) {
+                errors.push({ file, message: `Access mode "${mode}" requires method: "email" or "phone"` });
+            }
+        }
+        if (mode === "auth") {
+            if (!access.table)
+                errors.push({ file, message: `Access mode "auth" requires table` });
+            if (!access.matchColumn)
+                errors.push({ file, message: `Access mode "auth" requires matchColumn` });
+        }
+    }
+}
+function validateField(file, field, errors) {
+    const name = field.name;
+    const type = field.type;
+    if (!name) {
+        errors.push({ file, message: "Field missing required property: name" });
+        return;
+    }
+    if (!type) {
+        errors.push({ file, message: `Field "${name}": missing required property: type` });
+        return;
+    }
+    if (!VALID_FIELD_TYPES.has(type)) {
+        errors.push({ file, message: `Field "${name}": invalid type "${type}" (valid: ${[...VALID_FIELD_TYPES].join(", ")})` });
+    }
+    if ((type === "select" || type === "multiselect") && !field.options) {
+        errors.push({ file, message: `Field "${name}": ${type} requires options array` });
+    }
+    if (type === "calculated") {
+        if (!field.expression) {
+            errors.push({ file, message: `Field "${name}": calculated field requires expression` });
+        }
+        if (field.format && !VALID_FORMATS.has(field.format)) {
+            errors.push({ file, message: `Field "${name}": invalid format "${field.format}" (valid: number, currency, percent)` });
+        }
+    }
+    if (field.showWhen) {
+        validateConditions(file, `field "${name}"`, field.showWhen, errors);
+    }
+    if (field.validate) {
+        if (!Array.isArray(field.validate)) {
+            errors.push({ file, message: `Field "${name}": validate must be an array` });
+        }
+        else {
+            for (const rule of field.validate) {
+                if (!rule.rule || !VALID_VALIDATION_RULES.has(rule.rule)) {
+                    errors.push({ file, message: `Field "${name}": invalid validation rule "${rule.rule}" (valid: ${[...VALID_VALIDATION_RULES].join(", ")})` });
+                }
+                if (rule.value == null) {
+                    errors.push({ file, message: `Field "${name}": validation rule "${rule.rule}" requires a value` });
+                }
+                if (!rule.message || typeof rule.message !== "string") {
+                    errors.push({ file, message: `Field "${name}": validation rule "${rule.rule}" requires a message string` });
+                }
+            }
+        }
+    }
+}
+function validateConditions(file, context, conditions, errors) {
+    if (!Array.isArray(conditions))
+        return;
+    for (const cond of conditions) {
+        if (!cond.field) {
+            errors.push({ file, message: `${context}: condition missing "field"` });
+        }
+        if (!cond.op) {
+            errors.push({ file, message: `${context}: condition missing "op"` });
+        }
+        else if (!VALID_OPERATORS.has(cond.op)) {
+            errors.push({ file, message: `${context}: invalid operator "${cond.op}" (valid: ${[...VALID_OPERATORS].join(", ")})` });
+        }
+    }
+}
+export function validateFormConfigErrors(file, cfg) {
+    const errors = [];
+    validateCollectOptions(file, cfg, errors);
+    return errors;
+}
+function extractObject(source, startIdx) {
+    let depth = 0;
+    for (let i = startIdx; i < source.length; i++) {
+        if (source[i] === "{")
+            depth++;
+        else if (source[i] === "}") {
+            depth--;
+            if (depth === 0)
+                return source.slice(startIdx, i + 1);
+        }
+    }
+    return null;
+}
+export function formList() {
+    const dir = process.cwd();
+    const config = loadMugJson(dir);
+    const workspace = config.name;
+    const forms = [];
+    const surfacesDir = join(dir, "src", "surfaces");
+    if (existsSync(surfacesDir)) {
+        for (const file of readdirSync(surfacesDir).filter((f) => f.endsWith(".json"))) {
+            try {
+                const cfg = JSON.parse(readFileSync(join(surfacesDir, file), "utf-8"));
+                if (cfg.type === "portal")
+                    continue;
+                forms.push({
+                    file: `src/surfaces/${file}`,
+                    id: file.replace(/\.json$/, ""),
+                    title: cfg.title ?? "(untitled)",
+                    handler: cfg.workflow ?? "(none)",
+                });
+            }
+            catch { }
+        }
+    }
+    const workflowsDir = join(dir, "src", "workflows");
+    if (existsSync(workflowsDir)) {
+        for (const file of readdirSync(workflowsDir).filter((f) => f.endsWith(".ts"))) {
+            const content = readFileSync(join(workflowsDir, file), "utf-8");
+            if (!content.includes("ctx.collect("))
+                continue;
+            const idMatch = content.match(/id:\s*["']([^"']+)["']/);
+            const titleMatch = content.match(/title:\s*["']([^"']+)["']/);
+            const workflowMatch = content.match(/workflow:\s*["']([^"']+)["']/);
+            forms.push({
+                file: `src/workflows/${file}`,
+                id: idMatch?.[1] ?? "(auto)",
+                title: titleMatch?.[1] ?? "(untitled)",
+                handler: workflowMatch?.[1] ?? "(none)",
+            });
+        }
+    }
+    if (forms.length === 0) {
+        console.log("No forms found. Create one with: mug form init <name>");
+        return;
+    }
+    console.log(`Forms in workspace "${workspace}":\n`);
+    for (const form of forms) {
+        console.log(`  ${form.title}`);
+        console.log(`    ID: ${form.id}`);
+        console.log(`    File: ${form.file}`);
+        console.log(`    Handler: ${form.handler}`);
+        console.log(`    Local: http://localhost:8787/${form.id}`);
+        console.log(`    Prod:  https://${workspace}.mug.work/${form.id}`);
+        console.log();
+    }
+}

package/dist/src/commands/init.d.ts

@@ -0,0 +1 @@
+export declare function init(name?: string): Promise<void>;

package/dist/src/commands/init.js

@@ -0,0 +1,139 @@
+import { existsSync, mkdirSync, writeFileSync } from "node:fs";
+import { join, dirname } from "node:path";
+import { execSync } from "node:child_process";
+import { sync } from "./sync.js";
+import { ensureDevEmail } from "./login.js";
+import { skillTemplates } from "../templates.js";
+export async function init(name) {
+    const dir = process.cwd();
+    const workspaceName = name || dirname(dir).split("/").pop() || "workspace";
+    if (existsSync(join(dir, "mug.json"))) {
+        console.error("mug.json already exists in this directory.");
+        process.exit(1);
+    }
+    // User code directories (root-level)
+    mkdirSync(join(dir, "agents"), { recursive: true });
+    mkdirSync(join(dir, "agents", "shared-skills"), { recursive: true });
+    mkdirSync(join(dir, "connectors"), { recursive: true });
+    mkdirSync(join(dir, "workflows"), { recursive: true });
+    mkdirSync(join(dir, "surfaces"), { recursive: true });
+    // Data sync directories
+    mkdirSync(join(dir, "files"), { recursive: true });
+    mkdirSync(join(dir, "databases"), { recursive: true });
+    // Internal directories
+    mkdirSync(join(dir, ".mug"), { recursive: true });
+    writeFileSync(join(dir, "files", ".remote"), JSON.stringify({ synced_at: null, files: {} }, null, 2) + "\n");
+    writeFileSync(join(dir, "databases", ".remote"), JSON.stringify({ synced_at: null, databases: {} }, null, 2) + "\n");
+    writeFileSync(join(dir, "mug.json"), JSON.stringify({
+        name: workspaceName,
+        id: null,
+        settings: {
+            timezone: Intl.DateTimeFormat().resolvedOptions().timeZone,
+        },
+        ai: {
+            routing: {
+                fast: "openai/gpt-5.4-nano",
+                balanced: "@cf/moonshotai/kimi-k2.6",
+                powerful: "anthropic/claude-sonnet-4-6",
+            },
+            billing: {
+                default: "mug-metered",
+                fast: "mug-metered",
+                balanced: "mug-metered",
+                powerful: "mug-metered",
+            },
+        },
+        sources: {},
+    }, null, 2) + "\n");
+    writeFileSync(join(dir, "slack.json"), JSON.stringify({
+        enabled: false,
+    }, null, 2) + "\n");
+    ensureDevEmail(join(dir, "mug.json"));
+    writeFileSync(join(dir, "package.json"), JSON.stringify({
+        name: workspaceName,
+        version: "0.1.0",
+        type: "module",
+        scripts: {
+            dev: "mug dev",
+            deploy: "mug deploy",
+        },
+        dependencies: {
+            "@mugwork/mug": "latest",
+            hono: "^4.12.18",
+        },
+        devDependencies: {
+            "@cloudflare/workers-types": "^4.20260402.1",
+            typescript: "^6.0.2",
+        },
+    }, null, 2) + "\n");
+    writeFileSync(join(dir, "tsconfig.json"), JSON.stringify({
+        compilerOptions: {
+            target: "ES2022",
+            module: "ES2022",
+            lib: ["ES2022"],
+            types: ["@cloudflare/workers-types"],
+            moduleResolution: "bundler",
+            strict: true,
+            skipLibCheck: true,
+            isolatedModules: true,
+            esModuleInterop: true,
+        },
+        include: ["**/*.ts"],
+    }, null, 2) + "\n");
+    writeFileSync(join(dir, ".gitignore"), [
+        "node_modules/",
+        "databases/*.db",
+        ".mug/",
+        ".wrangler/",
+        ".dev.vars",
+        "wrangler.toml",
+    ].join("\n") + "\n");
+    writeFileSync(join(dir, ".mug", "secrets"), "# Workspace secrets — DO NOT commit this file\n");
+    writeFileSync(join(dir, "CLAUDE.md"), `# ${workspaceName}
+
+<!-- mug:start -->
+<!-- mug:end -->
+`);
+    writeFileSync(join(dir, "AGENTS.md"), `# ${workspaceName}
+
+<!-- mug:start -->
+<!-- mug:end -->
+`);
+    mkdirSync(join(dir, ".cursor", "rules"), { recursive: true });
+    writeFileSync(join(dir, ".cursor", "rules", "mug.mdc"), `---
+description: Mug workspace instructions
+globs: ["**/*.ts", "**/*.json"]
+---
+
+<!-- mug:start -->
+<!-- mug:end -->
+`);
+    // Scaffold skills for all AI agents
+    for (const [skillPath, content] of Object.entries(skillTemplates)) {
+        const parts = skillPath.split("/");
+        const skillName = parts[0];
+        const fileName = parts[parts.length - 1];
+        if (fileName.endsWith(".md")) {
+            mkdirSync(join(dir, ".claude", "skills", skillName), { recursive: true });
+            writeFileSync(join(dir, ".claude", "skills", skillName, fileName), content);
+            mkdirSync(join(dir, ".agents", "skills", skillName), { recursive: true });
+            writeFileSync(join(dir, ".agents", "skills", skillName, fileName), content);
+        }
+        if (fileName.endsWith(".mdc")) {
+            writeFileSync(join(dir, ".cursor", "rules", fileName), content);
+        }
+    }
+    console.log(`Creating workspace "${workspaceName}"...`);
+    execSync("npm install", { cwd: dir, stdio: "inherit" });
+    execSync("git init", { cwd: dir, stdio: "pipe" });
+    await sync(dir);
+    execSync("git add -A", { cwd: dir, stdio: "pipe" });
+    execSync('git commit -m "mug init"', { cwd: dir, stdio: "pipe" });
+    console.log(`\nWorkspace "${workspaceName}" ready.`);
+    console.log(`  mug dev`);
+    console.log(`\nAI is included with credits on your plan.`);
+    console.log(`For unlimited AI, add your own API key (recommended):`);
+    console.log(`  mug secret set ai.anthropic=<your-key>`);
+    console.log(`  mug secret set ai.openai=<your-key>`);
+    console.log(`\nRestart your AI coding agent to load Mug's instruction and skill files.`);
+}

package/dist/src/commands/issue.d.ts

@@ -0,0 +1,7 @@
+interface IssueOptions {
+    dryRun?: boolean;
+    attachDiagnostics?: boolean;
+    token?: string;
+}
+export declare function issue(opts: IssueOptions): Promise<void>;
+export {};