@agentbridge1/cli 0.0.7 → 0.0.9

package/dist/intent-parser.js

@@ -0,0 +1,178 @@
+"use strict";
+/**
+ * Intent parser — extracts structured task specification from a raw intent string.
+ * All logic is deterministic: no LLM, no external calls.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseIntent = parseIntent;
+exports.buildTaskSpecificCriteria = buildTaskSpecificCriteria;
+const ACTIONS = ["fix", "add", "update", "refactor", "remove", "migrate", "rename", "revert", "delete", "implement", "improve", "patch"];
+const DOMAIN_KEYWORD_MAP = {
+    auth: ["auth", "login", "logout", "session", "token", "oauth", "jwt", "password", "signin", "signup", "sign-in", "sign-up", "register", "credential", "permission", "role"],
+    database: ["database", "db", "schema", "migration", "migrate", "prisma", "sql", "query", "table", "column", "index", "model", "seed", "orm"],
+    payments: ["payment", "payments", "billing", "stripe", "invoice", "subscription", "checkout", "webhook"],
+    api: ["api", "endpoint", "route", "handler", "controller", "request", "response", "rest", "graphql"],
+    ui: ["ui", "style", "css", "component", "page", "layout", "copy", "design", "render", "display", "view", "frontend", "html", "template"],
+    mcp: ["mcp", "agentbridge", "cursor", "rules"],
+    tests: ["test", "tests", "spec", "vitest", "jest", "coverage", "proof"],
+};
+const SYMPTOMS = {
+    "401": ["401", "unauthorized", "unauthenticated"],
+    "403": ["403", "forbidden"],
+    "404": ["404", "not found", "notfound"],
+    "500": ["500", "internal server error", "server error"],
+    "null": ["null", "undefined", "nan", "nil"],
+    "crash": ["crash", "crashes", "crashed", "exception", "throws", "throw"],
+    "loop": ["loop", "infinite loop", "recursion"],
+    "hang": ["hang", "hangs", "timeout", "deadlock"],
+    "slow": ["slow", "performance", "latency", "memory leak", "memory"],
+    "duplicate": ["duplicate", "duplicated", "twice"],
+    "missing": ["missing", "not showing", "not found"],
+};
+// Route pattern: /something or /something/else (no file extension)
+const ROUTE_RE = /(?<!\w)(\/[a-zA-Z0-9_-]+(?:\/[a-zA-Z0-9_:_-]+)*)/g;
+// File with extension: something.ts, SomeThing.tsx, etc.
+const FILE_RE = /\b([A-Za-z][A-Za-z0-9_-]*\.[a-z]{2,4})\b/g;
+// PascalCase class or model name (≥2 caps or starts with uppercase followed by lowercase+uppercase)
+const PASCAL_RE = /\b([A-Z][a-z]+(?:[A-Z][a-z]*)+)\b/g;
+// camelCase function name — at least one internal uppercase letter, no spaces
+const CAMEL_FN_RE = /\b([a-z][a-z0-9]*(?:[A-Z][a-z0-9]*)+)\b/g;
+// Quoted phrase
+const QUOTED_RE = /"([^"]+)"|'([^']+)'/g;
+function detectDomain(lower) {
+    for (const [domain, keywords] of Object.entries(DOMAIN_KEYWORD_MAP)) {
+        if (keywords.some((kw) => lower.includes(kw)))
+            return domain;
+    }
+    return null;
+}
+function detectAction(lower) {
+    for (const action of ACTIONS) {
+        if (lower.startsWith(action) || lower.includes(` ${action} `))
+            return action;
+    }
+    return null;
+}
+function detectSymptom(lower) {
+    for (const [symptom, patterns] of Object.entries(SYMPTOMS)) {
+        if (patterns.some((p) => lower.includes(p)))
+            return symptom;
+    }
+    return null;
+}
+function extractTargets(raw) {
+    const targets = new Set();
+    // Quoted phrases first
+    for (const m of raw.matchAll(QUOTED_RE)) {
+        const phrase = m[1] ?? m[2];
+        if (phrase)
+            targets.add(phrase.trim());
+    }
+    // API routes
+    for (const m of raw.matchAll(ROUTE_RE)) {
+        targets.add(m[1]);
+    }
+    // Files with extensions
+    for (const m of raw.matchAll(FILE_RE)) {
+        targets.add(m[1]);
+    }
+    // PascalCase (models, classes)
+    for (const m of raw.matchAll(PASCAL_RE)) {
+        targets.add(m[1]);
+    }
+    // camelCase function names — only when short enough to be a name, not prose
+    for (const m of raw.matchAll(CAMEL_FN_RE)) {
+        if (m[1].length <= 40)
+            targets.add(m[1]);
+    }
+    return [...targets];
+}
+function inferLayers(domain, targets, symptom, action, rawLower) {
+    const layers = [];
+    const hasRoute = targets.some((t) => t.startsWith("/"));
+    const hasMigration = action === "migrate" || targets.some((t) => t.toLowerCase().includes("migration"));
+    if (domain === "auth") {
+        if (symptom === "401" || symptom === "403")
+            layers.push("route_handler", "auth_middleware");
+        else if (hasRoute)
+            layers.push("route_handler", "auth_middleware");
+        else
+            layers.push("auth_middleware");
+    }
+    if (domain === "api") {
+        if (hasRoute)
+            layers.push("route_handler");
+        else
+            layers.push("route_handler");
+    }
+    if (domain === "database") {
+        if (hasMigration)
+            layers.push("schema", "migration_file");
+        else
+            layers.push("model", "query");
+    }
+    if (domain === "ui") {
+        layers.push("component", "view");
+    }
+    if (domain === "payments") {
+        if (targets.some((t) => t.toLowerCase().includes("webhook")) || rawLower.includes("webhook")) {
+            layers.push("webhook_handler");
+        }
+        else {
+            layers.push("billing_handler");
+        }
+    }
+    if (domain === "mcp") {
+        layers.push("mcp_server", "config");
+    }
+    return layers;
+}
+function parseIntent(raw) {
+    if (!raw?.trim()) {
+        return { raw: raw ?? "", domain: null, targets: [], symptom: null, action: null, affected_layer: [] };
+    }
+    const lower = raw.toLowerCase();
+    const domain = detectDomain(lower);
+    const action = detectAction(lower);
+    const symptom = detectSymptom(lower);
+    const targets = extractTargets(raw);
+    const affected_layer = inferLayers(domain, targets, symptom, action, lower);
+    return { raw, domain, targets, symptom, action, affected_layer };
+}
+/**
+ * Builds task-specific criteria to prepend/append to a profile's generic criteria.
+ * Returns at most 2 sentences so the checklist stays readable.
+ */
+function buildTaskSpecificCriteria(parsed) {
+    const extra = [];
+    const routeTargets = parsed.targets.filter((t) => t.startsWith("/"));
+    const fileTargets = parsed.targets.filter((t) => t.includes("."));
+    const namedTargets = parsed.targets.filter((t) => !t.startsWith("/") && !t.includes("."));
+    // Task-specific entry criterion (what to look at)
+    if (routeTargets.length > 0 && parsed.domain === "auth" && parsed.symptom) {
+        extra.push(`The ${routeTargets[0]} route handler or its auth middleware chain is updated to address the ${parsed.symptom}.`);
+    }
+    else if (routeTargets.length > 0 && parsed.domain === "api") {
+        extra.push(`The ${routeTargets[0]} endpoint handler is updated as intended.`);
+    }
+    else if (routeTargets.length > 0) {
+        extra.push(`Changes are focused on the ${routeTargets[0]} route.`);
+    }
+    else if (fileTargets.length > 0) {
+        extra.push(`Changes are focused on ${fileTargets[0]}.`);
+    }
+    else if (namedTargets.length > 0) {
+        extra.push(`Changes are focused on ${namedTargets[0]}.`);
+    }
+    // Task-specific proof criterion (what to verify)
+    if (parsed.symptom && routeTargets.length > 0) {
+        extra.push(`Proof exists for the ${parsed.symptom} behavior on ${routeTargets[0]}.`);
+    }
+    else if (parsed.symptom) {
+        extra.push(`Proof exists that the ${parsed.symptom} condition is resolved.`);
+    }
+    else if (parsed.action && parsed.domain) {
+        extra.push(`Proof exists that the ${parsed.action} to the ${parsed.domain} layer is correct.`);
+    }
+    return extra;
+}

package/dist/intent-validation.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isVagueIntent = isVagueIntent;
+exports.validateIntent = validateIntent;
+const errors_1 = require("./errors");
+const VAGUE_PHRASES = [
+    "working on project",
+    "making changes",
+    "updating files",
+    "fix stuff",
+    "general work",
+];
+function isVagueIntent(intent) {
+    const lower = intent.trim().toLowerCase();
+    if (!lower)
+        return true;
+    if (lower.split(/\s+/).length < 4)
+        return true;
+    return VAGUE_PHRASES.some((phrase) => lower.includes(phrase));
+}
+function validateIntent(intent) {
+    const trimmed = intent.trim();
+    if (!trimmed) {
+        throw (0, errors_1.catalogCliError)("START_SUMMARY_REQUIRED", {
+            what: "A work contract intent is required.",
+            next: 'Run: agentbridge start "Fix auth 401 on /rooms endpoint"',
+        });
+    }
+    if (isVagueIntent(trimmed)) {
+        throw (0, errors_1.catalogCliError)("START_SUMMARY_REQUIRED", {
+            what: "Intent is too vague for a work contract.",
+            why: "AgentBridge needs a specific goal to compare against file changes.",
+            next: 'Use a concrete intent, e.g. agentbridge start "Fix auth 401 on /rooms endpoint"',
+        });
+    }
+    return trimmed;
+}

package/dist/local-proof.js

@@ -11,10 +11,18 @@ function normalizePath(path) {
     return path.trim().replaceAll("\\", "/");
 }
 function isProofNoiseFile(file) {
-    const normalized = normalizePath(file).toLowerCase();
-    return (normalized === "agentbridge.md" ||
-        normalized === ".cursor" ||
-        normalized.startsWith(".cursor/"));
+    const normalized = normalizePath(file);
+    const lower = normalized.toLowerCase();
+    if (lower === "agentbridge.md" ||
+        lower === ".cursor" ||
+        lower.startsWith(".cursor/")) {
+        return true;
+    }
+    // Vite ephemeral config bundles (e.g. vite.config.ts.timestamp-1781442511868-*.mjs)
+    if (/\.timestamp-\d+-[a-z0-9]+\.mjs$/i.test(normalized)) {
+        return true;
+    }
+    return false;
 }
 function normalizeProofMatchingFileSet(files) {
     return [...new Set(files.map(normalizePath).filter((file) => file.length > 0 && !isProofNoiseFile(file)))].sort();