designwithai-mcp 0.1.0

package/dist/skills.js

@@ -0,0 +1,57 @@
+/**
+ * Chargement de la bibliothèque de skills (`skills/`).
+ *
+ * Comme pour le Handbook, le serveur ne recopie rien : il lit les `SKILL.md`
+ * canoniques. Chaque skill devient un PROMPT MCP self-contained (socle commun +
+ * corps du skill + invocation renseignée) que Claude ou un IDE peut déclencher.
+ */
+import { existsSync, readFileSync, readdirSync } from "node:fs";
+import path from "node:path";
+import { skillsRoot } from "./paths.js";
+function parseFrontmatter(raw) {
+    const m = raw.match(/^---\n([\s\S]*?)\n---\n?([\s\S]*)$/);
+    if (!m)
+        return { fm: {}, body: raw.trim() };
+    const fm = {};
+    for (const line of m[1].split("\n")) {
+        const mm = line.match(/^([A-Za-z_]+):\s*(.*)$/);
+        if (mm)
+            fm[mm[1]] = mm[2].trim();
+    }
+    return { fm, body: m[2].trim() };
+}
+export function loadSkills() {
+    const dir = skillsRoot();
+    if (!existsSync(dir))
+        return { skills: [], sharedContract: "", origin: dir };
+    const sharedDir = path.join(dir, "_shared");
+    const sharedOrder = [
+        "execution-contract.md",
+        "issue-schema.md",
+        "severity-model.md",
+        "delivery-modes.md",
+    ];
+    const sharedContract = existsSync(sharedDir)
+        ? sharedOrder
+            .filter((f) => existsSync(path.join(sharedDir, f)))
+            .map((f) => readFileSync(path.join(sharedDir, f), "utf8").trim())
+            .join("\n\n---\n\n")
+        : "";
+    const skills = [];
+    for (const entry of readdirSync(dir, { withFileTypes: true })) {
+        if (!entry.isDirectory() || entry.name === "_shared")
+            continue;
+        const p = path.join(dir, entry.name, "SKILL.md");
+        if (!existsSync(p))
+            continue;
+        const { fm, body } = parseFrontmatter(readFileSync(p, "utf8"));
+        skills.push({
+            name: fm.name ?? entry.name,
+            description: fm.description ?? "",
+            role: fm.role ?? "",
+            body,
+        });
+    }
+    skills.sort((a, b) => a.name.localeCompare(b.name));
+    return { skills, sharedContract, origin: dir };
+}

package/dist/state.js

@@ -0,0 +1,48 @@
+/**
+ * L'état de progression, côté MCP — version locale.
+ *
+ * Miroir exact de la forme persistée par le site (`lib/store.ts`) : les gates
+ * franchis, chacun avec sa preuve (`artifactRef`) et sa date. Grâce à cette
+ * forme identique, le pont Supabase (étape D « complète ») se branchera dessus
+ * sans reformater. Ici tout reste local dans `.designwithai/state.json` —
+ * aucun secret, aucune auth.
+ *
+ * Discipline du produit conservée : un gate ne se ferme QUE sur un artefact
+ * localisable (voir `clear_gate` côté serveur).
+ */
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import path from "node:path";
+import { workspaceDir } from "./paths.js";
+export function statePath() {
+    return process.env.DWAI_STATE_PATH ?? workspaceDir("state.json");
+}
+export function loadState() {
+    const p = statePath();
+    if (existsSync(p)) {
+        try {
+            const s = JSON.parse(readFileSync(p, "utf8"));
+            return { gates: s.gates ?? {}, maturity: s.maturity ?? {} };
+        }
+        catch {
+            /* fichier illisible : on repart d'un état vide */
+        }
+    }
+    return { gates: {}, maturity: {} };
+}
+export function saveState(state) {
+    const p = statePath();
+    mkdirSync(path.dirname(p), { recursive: true });
+    writeFileSync(p, `${JSON.stringify(state, null, 2)}\n`);
+    return p;
+}
+export function clearGate(state, gateId, artifactRef, now) {
+    return {
+        ...state,
+        gates: { ...state.gates, [gateId]: { artifactRef, clearedAt: now.toISOString() } },
+    };
+}
+export function reopenGate(state, gateId) {
+    const gates = { ...state.gates };
+    delete gates[gateId];
+    return { ...state, gates };
+}