npm - @multileaf/ai-workflow - Versions diffs - 0.1.0 - Mend

@multileaf/ai-workflow 0.1.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (165) hide show

package/CHANGELOG.md +22 -0
package/LICENSE +21 -0
package/README.md +32 -0
package/dist/adapter-contract.d.ts +13 -0
package/dist/adapter-contract.js +50 -0
package/dist/adapter.d.ts +15 -0
package/dist/adapter.js +62 -0
package/dist/claude-layout.d.ts +9 -0
package/dist/claude-layout.js +23 -0
package/dist/cli.d.ts +4 -0
package/dist/cli.js +30 -0
package/dist/codex-layout.d.ts +10 -0
package/dist/codex-layout.js +24 -0
package/dist/confirmation.d.ts +9 -0
package/dist/confirmation.js +41 -0
package/dist/constants.d.ts +3 -0
package/dist/constants.js +10 -0
package/dist/context-cache.d.ts +8 -0
package/dist/context-cache.js +17 -0
package/dist/context-quality.d.ts +11 -0
package/dist/context-quality.js +27 -0
package/dist/context-retrieval.d.ts +3 -0
package/dist/context-retrieval.js +13 -0
package/dist/context-store.d.ts +9 -0
package/dist/context-store.js +18 -0
package/dist/copilot-layout.d.ts +9 -0
package/dist/copilot-layout.js +24 -0
package/dist/cursor-layout.d.ts +9 -0
package/dist/cursor-layout.js +25 -0
package/dist/dashboard.d.ts +37 -0
package/dist/dashboard.js +251 -0
package/dist/drift.d.ts +2 -0
package/dist/drift.js +10 -0
package/dist/evidence.d.ts +20 -0
package/dist/evidence.js +32 -0
package/dist/files.d.ts +2 -0
package/dist/files.js +58 -0
package/dist/gemini-layout.d.ts +9 -0
package/dist/gemini-layout.js +23 -0
package/dist/generator.d.ts +3 -0
package/dist/generator.js +16 -0
package/dist/intelligence.d.ts +2 -0
package/dist/intelligence.js +13 -0
package/dist/interpreter.d.ts +23 -0
package/dist/interpreter.js +117 -0
package/dist/lockfile.d.ts +12 -0
package/dist/lockfile.js +59 -0
package/dist/manifest.d.ts +15 -0
package/dist/manifest.js +35 -0
package/dist/migration.d.ts +22 -0
package/dist/migration.js +50 -0
package/dist/orchestration.d.ts +30 -0
package/dist/orchestration.js +172 -0
package/dist/organization-policy.d.ts +14 -0
package/dist/organization-policy.js +47 -0
package/dist/package-audit.d.ts +19 -0
package/dist/package-audit.js +28 -0
package/dist/package-contract.d.ts +30 -0
package/dist/package-contract.js +93 -0
package/dist/package-integrity.d.ts +8 -0
package/dist/package-integrity.js +15 -0
package/dist/package-updates.d.ts +11 -0
package/dist/package-updates.js +32 -0
package/dist/plugin-sdk.d.ts +20 -0
package/dist/plugin-sdk.js +243 -0
package/dist/policy-gate.d.ts +6 -0
package/dist/policy-gate.js +20 -0
package/dist/profile.d.ts +23 -0
package/dist/profile.js +123 -0
package/dist/providers.d.ts +20 -0
package/dist/providers.js +67 -0
package/dist/quality-gates.d.ts +2 -0
package/dist/quality-gates.js +40 -0
package/dist/recommendations.d.ts +12 -0
package/dist/recommendations.js +63 -0
package/dist/registry.d.ts +11 -0
package/dist/registry.js +27 -0
package/dist/scanner.d.ts +9 -0
package/dist/scanner.js +83 -0
package/dist/selection.d.ts +3 -0
package/dist/selection.js +11 -0
package/dist/self-validation.d.ts +9 -0
package/dist/self-validation.js +9 -0
package/dist/services.d.ts +42 -0
package/dist/services.js +1 -0
package/dist/team-configuration.d.ts +23 -0
package/dist/team-configuration.js +104 -0
package/dist/telemetry.d.ts +20 -0
package/dist/telemetry.js +95 -0
package/dist/token-usage.d.ts +9 -0
package/dist/token-usage.js +38 -0
package/dist/traceability.d.ts +23 -0
package/dist/traceability.js +51 -0
package/dist/types.d.ts +22 -0
package/dist/types.js +1 -0
package/dist/universal-layout.d.ts +9 -0
package/dist/universal-layout.js +21 -0
package/dist/vercel-skills.d.ts +17 -0
package/dist/vercel-skills.js +49 -0
package/dist/workflow.d.ts +4 -0
package/dist/workflow.js +1130 -0
package/docs/README.md +20 -0
package/docs/adapter-model.md +16 -0
package/docs/architecture.md +66 -0
package/docs/backlog.md +93 -0
package/docs/orchestration.md +50 -0
package/docs/package-model.md +53 -0
package/docs/plugin-authoring.md +31 -0
package/docs/product-requirements.md +57 -0
package/docs/product-vision.md +26 -0
package/docs/project-intelligence.md +59 -0
package/docs/quality.md +32 -0
package/docs/release-backlog.md +7 -0
package/docs/release-process.md +38 -0
package/docs/security.md +18 -0
package/docs/telemetry.md +28 -0
package/docs/token-efficiency.md +16 -0
package/package.json +76 -0
package/resources/README.md +4 -0
package/resources/agents/adapter-engineer.md +4 -0
package/resources/agents/documentation-writer.md +4 -0
package/resources/agents/quality-reviewer.md +4 -0
package/resources/agents/requirements-analyst.md +4 -0
package/resources/agents/security-reviewer.md +4 -0
package/resources/agents/technical-architect.md +4 -0
package/resources/agents/test-engineer.md +4 -0
package/resources/agents/typescript-engineer.md +4 -0
package/resources/hooks/post-change.md +4 -0
package/resources/hooks/post-implementation.md +4 -0
package/resources/hooks/pre-commit.md +4 -0
package/resources/hooks/pre-implementation.md +4 -0
package/resources/hooks/pre-release.md +4 -0
package/resources/package.yaml +36 -0
package/resources/rules/architecture-policy.md +4 -0
package/resources/rules/completion-validation.md +19 -0
package/resources/rules/dependency-policy.md +4 -0
package/resources/rules/documentation-policy.md +4 -0
package/resources/rules/generated-files.md +4 -0
package/resources/rules/language-policy.md +4 -0
package/resources/rules/quality-gates.md +4 -0
package/resources/rules/security-policy.md +4 -0
package/resources/rules/self-validation.md +12 -0
package/resources/rules/tdd-policy.md +4 -0
package/resources/skills/adapter-development.md +9 -0
package/resources/skills/brainstorming.md +9 -0
package/resources/skills/code-review.md +9 -0
package/resources/skills/documentation-maintenance.md +9 -0
package/resources/skills/implementation-planning.md +9 -0
package/resources/skills/project-init.md +9 -0
package/resources/skills/requirements-specification.md +9 -0
package/resources/skills/security-review.md +9 -0
package/resources/skills/skill-authoring.md +9 -0
package/resources/skills/tdd-development.md +9 -0
package/resources/skills/technical-design.md +9 -0
package/resources/skills/verification.md +9 -0
package/resources/templates/brainstorm.md +16 -0
package/resources/templates/decision-record.md +12 -0
package/resources/templates/implementation-plan.md +12 -0
package/resources/templates/migration-report.md +14 -0
package/resources/templates/security-review.md +14 -0
package/resources/templates/specification.md +23 -0
package/resources/templates/task.md +14 -0
package/resources/templates/technical-design.md +14 -0
package/resources/templates/test-plan.md +12 -0
package/resources/templates/verification-report.md +12 -0

package/dist/dashboard.js ADDED Viewed

@@ -0,0 +1,251 @@
+import { createServer } from "node:http";
+import { isAbsolute, join, relative, sep } from "node:path";
+import { TARGETS } from "./types.js";
+export function buildDashboardModel(root, fs) {
+    const projectRoot = fs.realpath?.(root) ?? root;
+    const read = (path) => {
+        if (!fs.exists(path))
+            return "";
+        if (fs.pathType?.(path) === "symlink")
+            throw new Error(`Dashboard input cannot be a symbolic link: ${path}`);
+        const realPath = fs.realpath?.(path) ?? path;
+        if (!isInside(projectRoot, realPath))
+            throw new Error(`Dashboard input must stay inside the project: ${path}`);
+        return fs.read(path);
+    };
+    const aiw = join(root, ".aiw");
+    const manifest = read(join(aiw, "manifest.yml"));
+    const profile = read(join(aiw, "profile.yml"));
+    const recommendations = read(join(aiw, "recommendations.yml"));
+    const traceability = read(join(aiw, "generated/artifacts/traceability.yml"));
+    return {
+        project: manifest.match(/^\s{2}name:\s*(.+)$/m)?.[1]?.trim() ?? root.split("/").at(-1) ?? root,
+        target: manifest.match(/^\s{2}active:\s*(.+)$/m)?.[1]?.trim() ?? "not configured",
+        facts: blocks(profile, /^\s{2}- key:\s*(.+)$/gm).map(({ heading, body }) => ({
+            key: heading,
+            value: field(body, "value"),
+            state: field(body, "state"),
+            confidence: field(body, "confidence"),
+        })),
+        recommendations: blocks(recommendations, /^\s{2}- id:\s*(.+)$/gm).map(({ heading, body }) => ({
+            id: heading,
+            provider: field(body, "provider"),
+            selected: field(body, "selected") === "true",
+        })),
+        traceability: blocks(traceability, /^\s{2}- requirement:\s*(.+)$/gm).map(({ heading, body }) => ({
+            requirement: heading,
+            decisions: inlineList(field(body, "decisions")),
+            tasks: inlineList(field(body, "tasks")),
+            evidence: inlineList(field(body, "evidence")),
+        })),
+    };
+}
+export function renderDashboard(model, notice = "") {
+    const facts = model.facts.length
+        ? model.facts
+            .map((fact) => `<tr><th>${escapeHtml(fact.key)}</th><td>${escapeHtml(fact.value)}</td><td><span class="state">${escapeHtml(fact.state)}</span></td><td>${escapeHtml(fact.confidence)}</td></tr>`)
+            .join("")
+        : '<tr><td colspan="4" class="empty">Run <code>aiw scan</code> to build the project profile.</td></tr>';
+    const recommendations = model.recommendations.length
+        ? model.recommendations
+            .map((item) => `<li><span><strong>${escapeHtml(item.id)}</strong><small>${escapeHtml(item.provider)}</small></span><b class="${item.selected ? "selected" : "pending"}">${item.selected ? "Selected" : "Available"}</b></li>`)
+            .join("")
+        : '<li class="empty">Run <code>aiw recommend</code> to see project-specific capabilities.</li>';
+    const traces = model.traceability.length
+        ? model.traceability
+            .map((link) => `<article class="trace"><strong>${escapeHtml(link.requirement)}</strong><i></i><span>${escapeHtml(link.decisions.join(", ") || "No decision")}</span><i></i><span>${escapeHtml(link.tasks.join(", ") || "No task")}</span><i></i><span>${escapeHtml(link.evidence.join(", ") || "No evidence")}</span></article>`)
+            .join("")
+        : '<p class="empty">Run <code>aiw trace</code> to connect requirements to evidence.</p>';
+    const options = TARGETS.map((target) => `<option value="${target}"${target === model.target ? " selected" : ""}>${target}</option>`).join("");
+    return `<!doctype html><html lang="en"><head><meta charset="utf-8"><meta name="viewport" content="width=device-width,initial-scale=1"><title>${escapeHtml(model.project)} · AI Workflow</title><style>${styles}</style></head><body><header><p class="eyebrow">AI WORKFLOW / PROJECT CONTROL</p><h1>${escapeHtml(model.project)}</h1><div class="target">Active target <strong>${escapeHtml(model.target)}</strong></div></header><main>${notice ? `<p class="notice" role="status">${escapeHtml(notice)}</p>` : ""}<section><div class="section-title"><span>Profile</span><small>Confirmed project signals</small></div><div class="table-wrap"><table><thead><tr><th>Fact</th><th>Value</th><th>State</th><th>Confidence</th></tr></thead><tbody>${facts}</tbody></table></div></section><section><div class="section-title"><span>Recommendations</span><small>Capabilities matched to this repository</small></div><ul>${recommendations}</ul></section><section class="wide"><div class="section-title"><span>Traceability</span><small>Requirement → decision → task → evidence</small></div><div class="traces">${traces}</div></section><section class="wide migration"><div><div class="section-title"><span>Migration</span><small>Render neutral resources for another assistant</small></div><p>Changing target updates generated adapter files. Type <code>MIGRATE</code> to confirm.</p></div><form method="post" action="/migrate"><label>Target<select name="target">${options}</select></label><label>Confirmation<input name="confirmation" autocomplete="off" placeholder="MIGRATE" required></label><button type="submit">Migrate target</button></form></section></main><footer>Local-only dashboard · No external assets or telemetry</footer></body></html>`;
+}
+export async function startDashboard(root, fs, execute, port = 0) {
+    if (!fs.exists(join(root, ".aiw/manifest.yml")))
+        throw new Error("Run `aiw install` first.");
+    let notice = "";
+    const server = createServer(async (request, response) => {
+        response.setHeader("Content-Security-Policy", "default-src 'none'; style-src 'unsafe-inline'; form-action 'self'; base-uri 'none'; frame-ancestors 'none'");
+        response.setHeader("X-Content-Type-Options", "nosniff");
+        response.setHeader("Cache-Control", "no-store");
+        const address = server.address();
+        const expectedOrigin = address && typeof address !== "string" ? `http://127.0.0.1:${address.port}` : "";
+        if (request.headers.host !== expectedOrigin.slice("http://".length)) {
+            response.statusCode = 400;
+            response.end("Invalid host");
+            return;
+        }
+        if (request.method === "GET" && request.url === "/api/dashboard") {
+            try {
+                response.setHeader("Content-Type", "application/json; charset=utf-8");
+                response.end(JSON.stringify(buildDashboardModel(root, fs)));
+            }
+            catch {
+                response.statusCode = 500;
+                response.end(JSON.stringify({ error: "Dashboard project state is unsafe or unreadable." }));
+            }
+            return;
+        }
+        if (request.method === "POST" && request.url === "/migrate") {
+            try {
+                if (request.headers.origin !== expectedOrigin)
+                    throw new Error("Migration requests must originate from this dashboard.");
+                if (!/^application\/x-www-form-urlencoded(?:;\s*charset=utf-8)?$/i.test(request.headers["content-type"] ?? ""))
+                    throw new Error("Migration request content type is invalid.");
+                const params = parseForm(await requestBody(request));
+                const target = params.target;
+                if (!TARGETS.includes(target) || params.confirmation !== "MIGRATE")
+                    throw new Error("Select a supported target and type MIGRATE to confirm.");
+                const result = await execute(["target", target]);
+                notice = result.output ?? result.error ?? "Migration finished.";
+                if (result.exitCode !== 0) {
+                    renderResponse(response, 409, safeDashboardHtml(root, fs, notice));
+                    notice = "";
+                    return;
+                }
+                response.statusCode = 303;
+            }
+            catch (error) {
+                notice = error instanceof Error ? error.message : String(error);
+                renderResponse(response, 400, safeDashboardHtml(root, fs, notice));
+                notice = "";
+                return;
+            }
+            response.setHeader("Location", "/");
+            response.end();
+            return;
+        }
+        if (request.method !== "GET" || request.url !== "/") {
+            response.statusCode = 404;
+            response.end("Not found");
+            return;
+        }
+        response.setHeader("Content-Type", "text/html; charset=utf-8");
+        try {
+            response.end(renderDashboard(buildDashboardModel(root, fs), notice));
+        }
+        catch {
+            response.statusCode = 500;
+            response.end("Dashboard project state is unsafe or unreadable.");
+        }
+        notice = "";
+    });
+    await new Promise((resolve, reject) => {
+        server.once("error", reject);
+        server.listen(port, "127.0.0.1", resolve);
+    });
+    const address = server.address();
+    if (!address || typeof address === "string")
+        throw new Error("Dashboard address is unavailable.");
+    return { url: `http://127.0.0.1:${address.port}`, close: () => closeServer(server) };
+}
+function blocks(content, expression) {
+    const matches = [...content.matchAll(expression)];
+    return matches.map((match, index) => ({
+        heading: match[1].trim(),
+        body: content.slice(match.index, matches[index + 1]?.index ?? content.length),
+    }));
+}
+function field(block, name) {
+    return block.match(new RegExp(`^\\s{4}${name}:\\s*(.*)$`, "m"))?.[1]?.trim() ?? "unknown";
+}
+function inlineList(value) {
+    if (!value.startsWith("[") || !value.endsWith("]"))
+        return [];
+    const items = [];
+    let current = "";
+    let quoted = false;
+    let escaped = false;
+    for (const character of value.slice(1, -1)) {
+        if (escaped) {
+            current += character;
+            escaped = false;
+        }
+        else if (character === "\\" && quoted) {
+            current += character;
+            escaped = true;
+        }
+        else if (character === '"') {
+            current += character;
+            quoted = !quoted;
+        }
+        else if (character === "," && !quoted) {
+            items.push(current);
+            current = "";
+        }
+        else {
+            current += character;
+        }
+    }
+    items.push(current);
+    return items.map(parseInlineItem).filter(Boolean);
+}
+function parseInlineItem(value) {
+    const item = value.trim();
+    if (item.startsWith('"') && item.endsWith('"')) {
+        try {
+            return JSON.parse(item);
+        }
+        catch {
+            return item.slice(1, -1);
+        }
+    }
+    return item;
+}
+function escapeHtml(value) {
+    return value
+        .replaceAll("&", "&amp;")
+        .replaceAll("<", "&lt;")
+        .replaceAll(">", "&gt;")
+        .replaceAll('"', "&quot;")
+        .replaceAll("'", "&#39;");
+}
+async function requestBody(request) {
+    const chunks = [];
+    let size = 0;
+    for await (const chunk of request) {
+        const value = Buffer.from(chunk);
+        size += value.length;
+        if (size > 4096)
+            throw new Error("Request body is too large.");
+        chunks.push(value);
+    }
+    return new TextDecoder("utf-8", { fatal: true }).decode(Buffer.concat(chunks));
+}
+function parseForm(body) {
+    const values = new Map();
+    for (const pair of body.split("&")) {
+        const separator = pair.indexOf("=");
+        if (!pair || separator <= 0 || separator !== pair.lastIndexOf("="))
+            throw new Error("Migration request form is malformed.");
+        const decode = (value) => decodeURIComponent(value.replaceAll("+", " "));
+        const key = decode(pair.slice(0, separator));
+        const value = decode(pair.slice(separator + 1));
+        if (!["target", "confirmation"].includes(key) || values.has(key))
+            throw new Error("Migration request fields are invalid or duplicated.");
+        values.set(key, value);
+    }
+    if (values.size !== 2 || !values.has("target") || !values.has("confirmation"))
+        throw new Error("Migration request fields are incomplete.");
+    return { target: values.get("target") ?? "", confirmation: values.get("confirmation") ?? "" };
+}
+function closeServer(server) {
+    return new Promise((resolve, reject) => server.close((error) => (error ? reject(error) : resolve())));
+}
+function renderResponse(response, status, html) {
+    response.statusCode = status;
+    response.setHeader("Content-Type", "text/html; charset=utf-8");
+    response.end(html);
+}
+function safeDashboardHtml(root, fs, notice) {
+    try {
+        return renderDashboard(buildDashboardModel(root, fs), notice);
+    }
+    catch {
+        return `<!doctype html><html lang="en"><head><meta charset="utf-8"><meta name="viewport" content="width=device-width,initial-scale=1"><title>AI Workflow</title></head><body><main><h1>AI Workflow</h1><p role="alert">${escapeHtml(notice)}</p><p>Dashboard project state is unsafe or unreadable.</p></main></body></html>`;
+    }
+}
+function isInside(root, destination) {
+    const path = relative(root, destination);
+    return path === "" || (path !== ".." && !path.startsWith(`..${sep}`) && !isAbsolute(path));
+}
+const styles = `:root{color-scheme:dark;--ink:#09111f;--panel:#101d30;--line:#29405d;--text:#e8f1fa;--muted:#8fa6bd;--cyan:#55d6d0;--amber:#f0b35a}*{box-sizing:border-box}body{margin:0;background:radial-gradient(circle at 80% 0,#173251 0,transparent 35%),var(--ink);color:var(--text);font:15px/1.55 ui-sans-serif,system-ui,sans-serif;overflow-wrap:anywhere}header,main,footer{max-width:1180px;margin:auto;min-width:0}header{padding:52px 24px 30px;border-bottom:1px solid var(--line);position:relative}h1{font:700 clamp(2.4rem,7vw,5.5rem)/.9 ui-monospace,SFMono-Regular,monospace;letter-spacing:-.08em;margin:.2em 0;overflow-wrap:anywhere}.eyebrow,.section-title,small,footer{color:var(--muted);letter-spacing:.08em;text-transform:uppercase;font:600 11px/1.4 ui-monospace,monospace}.target{position:absolute;right:24px;bottom:32px}.target strong,.state{color:var(--cyan)}main{padding:28px 24px;display:grid;grid-template-columns:1.3fr .7fr;gap:18px}section{background:color-mix(in srgb,var(--panel) 88%,transparent);border:1px solid var(--line);padding:22px;min-width:0}.wide{grid-column:1/-1}.section-title{display:flex;justify-content:space-between;gap:12px;color:var(--text);margin-bottom:18px}.section-title small{color:var(--muted);text-align:right}section:not(.wide) .section-title{align-items:flex-start;flex-direction:column}section:not(.wide) .section-title small{text-align:left}table{width:100%;border-collapse:collapse;text-align:left}th,td{padding:10px;border-bottom:1px solid var(--line)}thead th{color:var(--muted);font-size:11px;text-transform:uppercase}tbody th{font-family:ui-monospace,monospace}ul{list-style:none;padding:0;margin:0}li{display:flex;justify-content:space-between;padding:11px 0;border-bottom:1px solid var(--line)}li small{display:block}.selected{color:var(--cyan)}.pending{color:var(--amber)}.trace{display:grid;grid-template-columns:auto minmax(20px,1fr) auto minmax(20px,1fr) auto minmax(20px,1fr) auto;align-items:center;gap:10px;margin:12px 0;font-family:ui-monospace,monospace}.trace>*{min-width:0;overflow-wrap:anywhere}.trace i{height:1px;background:linear-gradient(90deg,var(--cyan),var(--line));position:relative}.trace i:after{content:'›';position:absolute;right:-2px;top:-12px;color:var(--cyan)}.migration{display:flex;justify-content:space-between;gap:24px;align-items:end}.migration form{display:flex;gap:10px;align-items:end}label{color:var(--muted);font-size:12px}select,input,button{display:block;margin-top:5px;background:var(--ink);color:var(--text);border:1px solid var(--line);padding:10px 12px;font:inherit;max-width:100%}button{background:var(--cyan);color:var(--ink);font-weight:800;cursor:pointer}button:focus-visible,select:focus-visible,input:focus-visible{outline:3px solid var(--amber);outline-offset:2px}.notice{grid-column:1/-1;border-left:3px solid var(--cyan);padding:12px 16px;background:var(--panel)}.empty{color:var(--muted)}code{font-family:ui-monospace,monospace;color:var(--cyan)}footer{padding:18px 24px 40px}@media(max-width:760px){header{padding-top:32px}.target{position:static}main{grid-template-columns:1fr}.wide{grid-column:auto}.migration,.migration form{display:grid}.trace{grid-template-columns:1fr}.trace i{width:28px}.table-wrap{overflow:auto}}@media(prefers-reduced-motion:no-preference){section{animation:enter .35s ease both}@keyframes enter{from{opacity:0;transform:translateY(8px)}}}`;

package/dist/drift.d.ts ADDED Viewed

	@@ -0,0 +1,2 @@
1	+ export declare function resolveGeneratedPath(path: string): string;
2	+ export declare function detectDrift(expected: string, actual: string): boolean;

package/dist/drift.js ADDED Viewed

@@ -0,0 +1,10 @@
+import { normalize } from "node:path";
+export function resolveGeneratedPath(path) {
+    const normalized = normalize(path).replaceAll("\\", "/");
+    if (normalized.startsWith("../") || normalized === ".." || normalized.startsWith("/"))
+        throw new Error("Generated path is outside generated resources");
+    return `generated/${normalized}`;
+}
+export function detectDrift(expected, actual) {
+    return expected !== actual;
+}

package/dist/evidence.d.ts ADDED Viewed

@@ -0,0 +1,20 @@
+import type { ProjectProfile } from "./profile.js";
+export type EvidenceState = "detected" | "inferred" | "confirmed";
+export type EvidenceMethod = "deterministic" | "ai-inference" | "user-confirmed";
+export type Evidence = {
+    source: string;
+    reason: string;
+};
+export type EvidenceFact = {
+    key: string;
+    value: string;
+    state: EvidenceState;
+    method: EvidenceMethod;
+    confidence: number;
+    requiresConfirmation?: boolean;
+    evidence: Evidence[];
+};
+export declare function buildFacts(profile: ProjectProfile, detectedEvidence?: {
+    fact: string;
+    source: string;
+}[]): EvidenceFact[];

package/dist/evidence.js ADDED Viewed

@@ -0,0 +1,32 @@
+export function buildFacts(profile, detectedEvidence = []) {
+    const facts = [];
+    const add = (key, value) => {
+        facts.push({
+            key,
+            value,
+            state: "detected",
+            method: "deterministic",
+            confidence: 1,
+            evidence: detectedEvidence
+                .filter((item) => item.fact === key ||
+                item.fact.endsWith(`.${value}`) ||
+                (key === "tool.linter" && item.fact === "tool.eslint") ||
+                (key === "tool.formatter" && item.fact === "tool.prettier") ||
+                (key === "tool.testing" && item.fact === `tool.${value}`))
+                .map((item) => ({ source: item.source, reason: "" })),
+        });
+    };
+    profile.runtime.languages.forEach((language) => add("runtime.language", language));
+    profile.frameworks.forEach((framework) => add("framework", framework));
+    if (profile.packageManager !== "unknown")
+        add("package-manager", profile.packageManager);
+    if (profile.quality.linter)
+        add("tool.linter", profile.quality.linter.name);
+    if (profile.quality.formatter)
+        add("tool.formatter", profile.quality.formatter.name);
+    if (profile.testing)
+        add("tool.testing", profile.testing.name);
+    profile.ci.forEach((provider) => add("ci.provider", provider));
+    profile.workspaces.forEach((workspace) => add("workspace", workspace));
+    return facts;
+}

package/dist/files.d.ts ADDED Viewed

	@@ -0,0 +1,2 @@
1	+ import type { FileSystem } from "./types.js";
2	+ export declare const nodeFileSystem: FileSystem;

package/dist/files.js ADDED Viewed

@@ -0,0 +1,58 @@
+import { existsSync, mkdirSync, readdirSync, readFileSync, unlinkSync, writeFileSync, openSync, closeSync, lstatSync, realpathSync, } from "node:fs";
+import { dirname, join } from "node:path";
+export const nodeFileSystem = {
+    exists: existsSync,
+    read: (path) => readFileSync(path, "utf8"),
+    readBytes: (path) => readFileSync(path),
+    write: (path, content) => {
+        mkdirSync(dirname(path), { recursive: true });
+        writeFileSync(path, content);
+    },
+    createExclusive: (path, content) => {
+        mkdirSync(dirname(path), { recursive: true });
+        try {
+            const descriptor = openSync(path, "wx");
+            try {
+                writeFileSync(descriptor, content);
+            }
+            finally {
+                closeSync(descriptor);
+            }
+            return true;
+        }
+        catch (error) {
+            if (error.code === "EEXIST")
+                return false;
+            throw error;
+        }
+    },
+    writeBytes: (path, content) => {
+        mkdirSync(dirname(path), { recursive: true });
+        writeFileSync(path, content);
+    },
+    mkdir: (path) => mkdirSync(path, { recursive: true }),
+    list: (path) => readdirSync(path).sort(),
+    listFiles: (path) => readdirSync(path, { recursive: true, withFileTypes: true })
+        .filter((entry) => entry.isFile())
+        .map((entry) => join(entry.parentPath.slice(path.length + 1), entry.name))
+        .sort(),
+    remove: unlinkSync,
+    pathType: (path) => {
+        try {
+            const entry = lstatSync(path);
+            if (entry.isSymbolicLink())
+                return "symlink";
+            if (entry.isFile())
+                return "file";
+            if (entry.isDirectory())
+                return "directory";
+            return "other";
+        }
+        catch (error) {
+            if (error.code === "ENOENT")
+                return "missing";
+            throw error;
+        }
+    },
+    realpath: realpathSync,
+};

package/dist/gemini-layout.d.ts ADDED Viewed

@@ -0,0 +1,9 @@
+import type { ResourceType } from "./package-contract.js";
+import type { FileSystem } from "./types.js";
+export type GeminiResourceType = ResourceType | "context";
+export type GeminiResourceDescriptor = {
+    path: string;
+    support: "native" | "compatibility";
+};
+export declare function describeGeminiResource(type: GeminiResourceType, id: string): GeminiResourceDescriptor;
+export declare function renderGeminiContext(root: string, content: string, fs: FileSystem): string;

package/dist/gemini-layout.js ADDED Viewed

@@ -0,0 +1,23 @@
+import { join } from "node:path";
+export function describeGeminiResource(type, id) {
+    if (type === "skills")
+        return { path: `.gemini/skills/${id}/SKILL.md`, support: "native" };
+    if (type === "agents")
+        return { path: `.gemini/agents/${id}.md`, support: "native" };
+    if (type === "context")
+        return { path: "GEMINI.md", support: "native" };
+    const roots = {
+        rules: ".gemini/aiw/rules",
+        hooks: ".gemini/aiw/hooks",
+        templates: ".gemini/aiw/templates",
+    };
+    const root = roots[type];
+    if (!root)
+        throw new Error(`Unsupported Gemini resource type: ${type}`);
+    return { path: `${root}/${id}.md`, support: "compatibility" };
+}
+export function renderGeminiContext(root, content, fs) {
+    const path = describeGeminiResource("context", "project").path;
+    fs.write(join(root, path), content);
+    return path;
+}

package/dist/generator.d.ts ADDED Viewed

@@ -0,0 +1,3 @@
+import type { ProjectProfile } from "./profile.js";
+export type ResourceWriter = (path: string, content: string) => void;
+export declare function generateProjectResources(profile: ProjectProfile, selected: string[], write: ResourceWriter): void;

package/dist/generator.js ADDED Viewed

@@ -0,0 +1,16 @@
+import { resolveGeneratedPath } from "./drift.js";
+export function generateProjectResources(profile, selected, write) {
+    const linterCommand = profile.quality.linter?.command;
+    const formatterCommand = profile.quality.formatter?.command;
+    const testCommand = profile.testing?.command;
+    if (selected.includes("typescript-quality"))
+        write(resolveGeneratedPath("rules/project-quality.md"), `# Project Quality Rules\n\n- Use ${profile.runtime.languages.map((language) => (language === "typescript" ? "TypeScript" : language)).join(", ")} with strict typing.\n${linterCommand ? `- Run \`${linterCommand}\` before completion.\n` : ""}${formatterCommand ? `- Run \`${formatterCommand}\` before review.\n` : ""}- Keep all generated AI Workflow artifacts in English.\n`);
+    if (selected.includes("tdd-development"))
+        write(resolveGeneratedPath("rules/tdd-project-policy.md"), `# TDD Project Policy\n\n${testCommand ? `- Run \`${testCommand}\` for verification.\n` : ""}- Write a failing behavioral test before implementation.\n- Refactor only after the test is green.\n`);
+    if (selected.includes("nextjs-development") || selected.includes("react-best-practices"))
+        write(resolveGeneratedPath("agents/project-context.md"), `# Project Context\n\nThis project uses ${profile.frameworks.map((framework) => (framework === "nextjs" ? "Next.js" : framework)).join(", ")}. Follow the detected project structure and existing framework conventions.\n`);
+    if (selected.length > 0) {
+        write(resolveGeneratedPath("context/project-profile.md"), `# Confirmed Project Profile\n\n- Languages: ${profile.runtime.languages.join(", ") || "none detected"}\n- Frameworks: ${profile.frameworks.join(", ") || "none detected"}\n- Package manager: ${profile.packageManager}\n- All generated content is in English.\n`);
+        write(resolveGeneratedPath("hooks/quality-check.md"), `# Quality Check Hook\n\nRun the available project quality commands before completion.${linterCommand ? `\n\n- Linter: \`${linterCommand}\`` : ""}${formatterCommand ? `\n- Formatter: \`${formatterCommand}\`` : ""}${testCommand ? `\n- Tests: \`${testCommand}\`` : ""}\n`);
+    }
+}

package/dist/intelligence.d.ts ADDED Viewed

	@@ -0,0 +1,2 @@
1	+ import type { EvidenceFact } from "./evidence.js";
2	+ export declare function mergeFacts(detected: EvidenceFact[], proposed: EvidenceFact[]): EvidenceFact[];

package/dist/intelligence.js ADDED Viewed

@@ -0,0 +1,13 @@
+export function mergeFacts(detected, proposed) {
+    const result = [...detected];
+    for (const candidate of proposed) {
+        const index = result.findIndex((fact) => fact.key === candidate.key);
+        if (index < 0) {
+            result.push(candidate);
+            continue;
+        }
+        if (candidate.state === "confirmed" && candidate.method === "user-confirmed")
+            result[index] = candidate;
+    }
+    return result;
+}

package/dist/interpreter.d.ts ADDED Viewed

@@ -0,0 +1,23 @@
+import type { EvidenceFact } from "./evidence.js";
+import type { ProjectProfile } from "./profile.js";
+export type InterpretationRequest = {
+    profile: ProjectProfile;
+    files: string[];
+    maxTokens: number;
+    estimatedTokens: number;
+};
+export type Interpreter = {
+    interpret(request: InterpretationRequest): Promise<EvidenceFact[]>;
+};
+export type AiProviderRequest = {
+    system: string;
+    prompt: string;
+    maxTokens: number;
+    responseFormat: "json";
+};
+export type AiProvider = {
+    generate(request: AiProviderRequest): Promise<string>;
+};
+export type ContextReader = (absolutePath: string) => Promise<string>;
+export declare function createInterpretationRequest(profile: ProjectProfile, files: string[], maxTokens?: number): InterpretationRequest;
+export declare function createProjectInterpreter(root: string, provider: AiProvider, contextReader?: ContextReader): Interpreter;

package/dist/interpreter.js ADDED Viewed

@@ -0,0 +1,117 @@
+import { lstat, readFile } from "node:fs/promises";
+import { isAbsolute, relative, resolve } from "node:path";
+const EXCLUDED_SEGMENT = /(^|\/)(\.git|node_modules|vendor|\.venv|venv|dist|build|coverage|out|target|\.next|\.nuxt|\.output)(\/|$)/i;
+const EXCLUDED_AIW = /(^|\/)\.aiw\/(generated|checkpoints)(\/|$)/i;
+const SENSITIVE = /(^|\/)\.env(?:\.[^/]*)?$|\.(pem|key|p12|pfx|secret)$/i;
+const TEXT_FILE = /(^|\/)(README|CONTRIBUTING|ARCHITECTURE)(\.[^/]*)?$|\.(c|cc|cpp|cs|css|go|graphql|h|hpp|html|java|js|jsx|json|kt|md|mjs|cjs|php|py|rb|rs|sh|sql|swift|toml|ts|tsx|txt|vue|yaml|yml)$/i;
+function safeFile(file) {
+    const normalized = file.replaceAll("\\", "/").replace(/^\.\//, "");
+    return (normalized.length > 0 &&
+        !isAbsolute(file) &&
+        !normalized.split("/").includes("..") &&
+        !EXCLUDED_SEGMENT.test(normalized) &&
+        !EXCLUDED_AIW.test(normalized) &&
+        !SENSITIVE.test(normalized) &&
+        TEXT_FILE.test(normalized));
+}
+function redactSecrets(content) {
+    return content
+        .replace(/-----BEGIN [^-]*PRIVATE KEY-----[\s\S]*?-----END [^-]*PRIVATE KEY-----/g, "[REDACTED]")
+        .replace(/\b(Bearer\s+)[A-Za-z0-9._~+/=-]+/gi, "$1[REDACTED]")
+        .replace(/\b(api[_-]?key|access[_-]?token|auth[_-]?token|client[_-]?secret|password)\b(\s*[=:]\s*)["']?[^\s,"'}]+/gi, "$1$2[REDACTED]");
+}
+function isBinary(content) {
+    return [...content].some((character) => {
+        const code = character.codePointAt(0) ?? 0;
+        return (code === 0 ||
+            (code >= 1 && code <= 8) ||
+            code === 11 ||
+            code === 12 ||
+            (code >= 14 && code <= 31));
+    });
+}
+export function createInterpretationRequest(profile, files, maxTokens = 4000) {
+    if (!Number.isInteger(maxTokens) || maxTokens <= 0)
+        throw new Error("maxTokens must be a positive integer");
+    const selectedFiles = [
+        ...new Set(files.filter(safeFile).map((file) => file.replaceAll("\\", "/"))),
+    ].sort();
+    return {
+        profile,
+        files: selectedFiles,
+        maxTokens,
+        estimatedTokens: Math.min(maxTokens, JSON.stringify(profile).length + selectedFiles.join("\n").length),
+    };
+}
+function parseFacts(output, allowedFiles) {
+    let value;
+    try {
+        value = JSON.parse(output);
+    }
+    catch {
+        throw new Error("AI provider returned invalid JSON");
+    }
+    const facts = value?.facts;
+    if (!Array.isArray(facts))
+        throw new Error("AI provider response must contain a facts array");
+    return facts.map((item) => {
+        if (typeof item.key !== "string" ||
+            typeof item.value !== "string" ||
+            typeof item.confidence !== "number" ||
+            item.confidence < 0 ||
+            item.confidence > 1 ||
+            !Array.isArray(item.evidence))
+            throw new Error("AI provider returned an invalid inferred fact");
+        const evidence = item.evidence.map((entry) => {
+            const candidate = entry;
+            if (typeof candidate.source !== "string" || typeof candidate.reason !== "string")
+                throw new Error("AI provider returned invalid evidence");
+            if (!allowedFiles.has(candidate.source))
+                throw new Error(`AI provider cited a file outside the scoped context: ${candidate.source}`);
+            return { source: candidate.source, reason: candidate.reason };
+        });
+        return {
+            key: item.key,
+            value: item.value,
+            state: "inferred",
+            method: "ai-inference",
+            confidence: item.confidence,
+            requiresConfirmation: item.confidence < 0.9,
+            evidence,
+        };
+    });
+}
+export function createProjectInterpreter(root, provider, contextReader = (path) => readFile(path, "utf8")) {
+    const projectRoot = resolve(root);
+    return {
+        async interpret(request) {
+            const scoped = createInterpretationRequest(request.profile, request.files, request.maxTokens);
+            const sections = [];
+            for (const file of scoped.files) {
+                const absolute = resolve(projectRoot, file);
+                if (relative(projectRoot, absolute).startsWith(".."))
+                    continue;
+                try {
+                    if ((await lstat(absolute)).isSymbolicLink())
+                        continue;
+                }
+                catch {
+                    // Injected context readers may provide virtual files in tests or adapters.
+                }
+                const content = await contextReader(absolute);
+                if (isBinary(content))
+                    continue;
+                sections.push(`## ${file}\n${redactSecrets(content)}`);
+            }
+            if (sections.length === 0)
+                return [];
+            const output = await provider.generate({
+                system: "Interpret project conventions from only the supplied context. Return JSON with a facts array. Each fact must have key, string value, confidence from 0 to 1, and evidence entries with source and reason. Do not infer secrets or repeat credentials.",
+                prompt: `Detected profile:\n${JSON.stringify(scoped.profile)}\n\nScoped project context:\n${sections.join("\n\n")}`,
+                maxTokens: scoped.maxTokens,
+                responseFormat: "json",
+            });
+            return parseFacts(output, new Set(scoped.files));
+        },
+    };
+}

package/dist/lockfile.d.ts ADDED Viewed

@@ -0,0 +1,12 @@
+import type { PackageContract } from "./package-contract.js";
+export type LockedPackage = {
+    id: string;
+    version: string;
+    provider: string;
+    source: string;
+    integrity: string;
+    permissions?: string[];
+};
+export declare function resolvePackage(pkg: PackageContract): LockedPackage;
+export declare function serializeLock(packages: LockedPackage[]): string;
+export declare function parseLock(content: string): LockedPackage[];