@siteping/cli 0.3.0

package/dist/index.js

@@ -0,0 +1,640 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { Command } from "commander";
+
+// src/commands/doctor.ts
+import * as p from "@clack/prompts";
+async function doctorCommand(options) {
+  p.intro("siteping \u2014 Diagnostic r\xE9seau");
+  const url = options.url ?? await p.text({
+    message: "URL du serveur de d\xE9veloppement",
+    placeholder: "http://localhost:3000",
+    defaultValue: "http://localhost:3000"
+  });
+  if (p.isCancel(url)) {
+    p.cancel("Annul\xE9.");
+    process.exit(0);
+  }
+  const endpoint = options.endpoint ?? await p.text({
+    message: "Chemin de l'endpoint API",
+    placeholder: "/api/siteping",
+    defaultValue: "/api/siteping"
+  });
+  if (p.isCancel(endpoint)) {
+    p.cancel("Annul\xE9.");
+    process.exit(0);
+  }
+  const fullUrl = `${url}${endpoint}?projectName=__siteping_health_check__`;
+  const spinner2 = p.spinner();
+  spinner2.start(`Test de connexion \xE0 ${url}${endpoint}`);
+  try {
+    const start = performance.now();
+    const response = await fetch(fullUrl);
+    const elapsed = Math.round(performance.now() - start);
+    if (response.ok) {
+      const data = await response.json();
+      spinner2.stop(`Connexion r\xE9ussie (${elapsed}ms)`);
+      if (data && typeof data.total === "number") {
+        p.log.success(`API fonctionnelle \u2014 ${data.total} feedback(s) trouv\xE9(s)`);
+      } else {
+        p.log.warn("R\xE9ponse inattendue \u2014 v\xE9rifiez que l'endpoint utilise createSitepingHandler()");
+      }
+    } else {
+      spinner2.stop(`Erreur HTTP ${response.status} (${elapsed}ms)`);
+      const text2 = await response.text().catch(() => "");
+      p.log.error(`Le serveur a r\xE9pondu : ${response.status} ${response.statusText}`);
+      if (text2) p.log.info(text2.slice(0, 200));
+    }
+  } catch (error) {
+    spinner2.stop("Connexion \xE9chou\xE9e");
+    if (error instanceof TypeError && String(error).includes("fetch")) {
+      p.log.error("Impossible de se connecter \u2014 le serveur est-il lanc\xE9 ?");
+      p.log.info(`V\xE9rifiez que ${url} est accessible`);
+    } else {
+      p.log.error(`Erreur : ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+  p.outro("Diagnostic termin\xE9");
+}
+
+// src/commands/init.ts
+import { existsSync as existsSync3 } from "fs";
+import { join as join2 } from "path";
+import * as p2 from "@clack/prompts";
+
+// src/generators/prisma.ts
+import { existsSync, readFileSync, writeFileSync } from "fs";
+import { getSchema, printSchema } from "@mrleebo/prisma-ast";
+
+// ../core/src/schema.ts
+var SITEPING_MODELS = {
+  SitepingFeedback: {
+    fields: {
+      id: { type: "String", isId: true, default: "cuid()" },
+      projectName: { type: "String" },
+      type: { type: "String" },
+      message: { type: "String" },
+      status: { type: "String", default: '"open"' },
+      url: { type: "String" },
+      viewport: { type: "String" },
+      userAgent: { type: "String" },
+      authorName: { type: "String" },
+      authorEmail: { type: "String" },
+      clientId: { type: "String", isUnique: true },
+      resolvedAt: { type: "DateTime", optional: true },
+      createdAt: { type: "DateTime", default: "now()" },
+      annotations: {
+        type: "SitepingAnnotation",
+        relation: { kind: "1-to-many", model: "SitepingAnnotation" }
+      }
+    }
+  },
+  SitepingAnnotation: {
+    fields: {
+      id: { type: "String", isId: true, default: "cuid()" },
+      feedbackId: { type: "String" },
+      feedback: {
+        type: "SitepingFeedback",
+        relation: {
+          kind: "many-to-1",
+          model: "SitepingFeedback",
+          fields: ["feedbackId"],
+          references: ["id"],
+          onDelete: "Cascade"
+        }
+      },
+      cssSelector: { type: "String" },
+      xpath: { type: "String" },
+      textSnippet: { type: "String" },
+      elementTag: { type: "String" },
+      elementId: { type: "String", optional: true },
+      textPrefix: { type: "String" },
+      textSuffix: { type: "String" },
+      fingerprint: { type: "String" },
+      neighborText: { type: "String" },
+      xPct: { type: "Float" },
+      yPct: { type: "Float" },
+      wPct: { type: "Float" },
+      hPct: { type: "Float" },
+      scrollX: { type: "Float" },
+      scrollY: { type: "Float" },
+      viewportW: { type: "Int" },
+      viewportH: { type: "Int" },
+      devicePixelRatio: { type: "Float", default: "1" },
+      createdAt: { type: "DateTime", default: "now()" }
+    }
+  }
+};
+
+// src/generators/prisma.ts
+var DEFAULT_SCHEMA_PATH = "prisma/schema.prisma";
+function syncPrismaModels(schemaPath = DEFAULT_SCHEMA_PATH) {
+  if (!existsSync(schemaPath)) {
+    throw new Error(`Schema file not found: ${schemaPath}`);
+  }
+  const source = readFileSync(schemaPath, "utf-8");
+  const schema = getSchema(source);
+  const existingModelsMap = /* @__PURE__ */ new Map();
+  for (const item of schema.list) {
+    if (item.type === "model") {
+      existingModelsMap.set(item.name, item);
+    }
+  }
+  const addedModels = [];
+  const changes = [];
+  for (const [modelName, modelDef] of Object.entries(SITEPING_MODELS)) {
+    const existingModel = existingModelsMap.get(modelName);
+    if (!existingModel) {
+      const model = { type: "model", name: modelName, properties: [] };
+      for (const [fieldName, fieldDef] of Object.entries(modelDef.fields)) {
+        model.properties.push(buildField(fieldName, fieldDef));
+      }
+      schema.list.push(model);
+      addedModels.push(modelName);
+      continue;
+    }
+    const existingFields = /* @__PURE__ */ new Map();
+    existingModel.properties.forEach((prop, idx) => {
+      if (prop.type === "field") {
+        existingFields.set(prop.name, { field: prop, index: idx });
+      }
+    });
+    const fieldsToAdd = [];
+    const fieldsToUpdate = [];
+    for (const [fieldName, fieldDef] of Object.entries(modelDef.fields)) {
+      const expected = buildField(fieldName, fieldDef);
+      const existing = existingFields.get(fieldName);
+      if (!existing) {
+        fieldsToAdd.push(expected);
+        changes.push({
+          model: modelName,
+          field: fieldName,
+          action: "added",
+          detail: formatFieldSignature(fieldDef)
+        });
+      } else if (!fieldsMatch(existing.field, expected)) {
+        fieldsToUpdate.push({ index: existing.index, field: expected });
+        changes.push({
+          model: modelName,
+          field: fieldName,
+          action: "updated",
+          detail: describeChange(existing.field, expected)
+        });
+      }
+    }
+    for (const { index, field } of fieldsToUpdate) {
+      existingModel.properties[index] = field;
+    }
+    if (fieldsToAdd.length > 0) {
+      const createdAtIdx = existingModel.properties.findIndex(
+        (p5) => p5.type === "field" && p5.name === "createdAt"
+      );
+      if (createdAtIdx >= 0) {
+        existingModel.properties.splice(createdAtIdx, 0, ...fieldsToAdd);
+      } else {
+        existingModel.properties.push(...fieldsToAdd);
+      }
+    }
+  }
+  if (addedModels.length > 0 || changes.length > 0) {
+    const output = printSchema(schema);
+    writeFileSync(schemaPath, output, "utf-8");
+  }
+  return { schemaPath, addedModels, changes };
+}
+function fieldsMatch(existing, expected) {
+  if (existing.fieldType !== expected.fieldType) return false;
+  if ((existing.optional ?? false) !== (expected.optional ?? false)) return false;
+  if ((existing.array ?? false) !== (expected.array ?? false)) return false;
+  const existingAttrs = (existing.attributes ?? []).map((a) => a.name).sort();
+  const expectedAttrs = (expected.attributes ?? []).map((a) => a.name).sort();
+  if (existingAttrs.length !== expectedAttrs.length) return false;
+  return existingAttrs.every((name, i) => name === expectedAttrs[i]);
+}
+function describeChange(existing, expected) {
+  const parts = [];
+  if (existing.fieldType !== expected.fieldType) {
+    parts.push(`${existing.fieldType} \u2192 ${expected.fieldType}`);
+  }
+  if ((existing.optional ?? false) !== (expected.optional ?? false)) {
+    parts.push(expected.optional ? "required \u2192 optional" : "optional \u2192 required");
+  }
+  const existingAttrs = new Set((existing.attributes ?? []).map((a) => a.name));
+  const expectedAttrs = new Set((expected.attributes ?? []).map((a) => a.name));
+  for (const attr of expectedAttrs) {
+    if (!existingAttrs.has(attr)) parts.push(`+@${attr}`);
+  }
+  for (const attr of existingAttrs) {
+    if (!expectedAttrs.has(attr)) parts.push(`-@${attr}`);
+  }
+  return parts.join(", ") || "attributes changed";
+}
+function formatFieldSignature(def) {
+  let sig = def.type;
+  if (def.optional) sig += "?";
+  return sig;
+}
+function buildField(name, def) {
+  const field = {
+    type: "field",
+    name,
+    fieldType: def.relation ? def.relation.model : def.type,
+    optional: def.optional ?? false,
+    array: def.relation?.kind === "1-to-many",
+    attributes: []
+  };
+  if (def.isId) {
+    field.attributes.push({ type: "attribute", name: "id", kind: "field" });
+    if (def.default) {
+      field.attributes.push({
+        type: "attribute",
+        name: "default",
+        kind: "field",
+        args: [
+          {
+            type: "attributeArgument",
+            value: { type: "function", name: def.default.replace("()", ""), params: [] }
+          }
+        ]
+      });
+    }
+  } else if (def.default && !def.relation) {
+    const isFunction = def.default.endsWith("()");
+    field.attributes.push({
+      type: "attribute",
+      name: "default",
+      kind: "field",
+      args: [
+        {
+          type: "attributeArgument",
+          value: isFunction ? { type: "function", name: def.default.replace("()", ""), params: [] } : def.default
+        }
+      ]
+    });
+  }
+  if (def.isUnique) {
+    field.attributes.push({ type: "attribute", name: "unique", kind: "field" });
+  }
+  if (def.relation?.kind === "many-to-1") {
+    const args = [];
+    if (def.relation.fields) {
+      args.push({
+        type: "attributeArgument",
+        value: { type: "keyValue", key: "fields", value: { type: "array", args: def.relation.fields } }
+      });
+    }
+    if (def.relation.references) {
+      args.push({
+        type: "attributeArgument",
+        value: { type: "keyValue", key: "references", value: { type: "array", args: def.relation.references } }
+      });
+    }
+    if (def.relation.onDelete) {
+      args.push({
+        type: "attributeArgument",
+        value: { type: "keyValue", key: "onDelete", value: def.relation.onDelete }
+      });
+    }
+    field.attributes.push({
+      type: "attribute",
+      name: "relation",
+      kind: "field",
+      args
+    });
+  }
+  return field;
+}
+
+// src/generators/route.ts
+import { existsSync as existsSync2, mkdirSync, writeFileSync as writeFileSync2 } from "fs";
+import { dirname, join } from "path";
+var ROUTE_TEMPLATE = `import { createSitepingHandler } from "@siteping/adapter-prisma";
+import { prisma } from "@/lib/prisma";
+
+export const { GET, POST, PATCH, DELETE } = createSitepingHandler({ prisma });
+`;
+function generateRoute(basePath = process.cwd()) {
+  const appDir = existsSync2(join(basePath, "src", "app")) ? join(basePath, "src", "app") : join(basePath, "app");
+  if (!existsSync2(appDir)) {
+    throw new Error(`Could not find app/ directory. Are you in a Next.js App Router project?`);
+  }
+  const routePath = join(appDir, "api", "siteping", "route.ts");
+  if (existsSync2(routePath)) {
+    return { created: false, path: routePath };
+  }
+  mkdirSync(dirname(routePath), { recursive: true });
+  writeFileSync2(routePath, ROUTE_TEMPLATE, "utf-8");
+  return { created: true, path: routePath };
+}
+
+// src/commands/init.ts
+async function initCommand() {
+  p2.intro("siteping \u2014 Configuration");
+  const cwd = process.cwd();
+  const schemaPath = findPrismaSchema(cwd);
+  if (schemaPath) {
+    p2.log.info(`Schema Prisma trouv\xE9 : ${schemaPath}`);
+    const shouldSync = await p2.confirm({
+      message: "Synchroniser les mod\xE8les Siteping dans le schema Prisma ?"
+    });
+    if (p2.isCancel(shouldSync)) {
+      p2.cancel("Annul\xE9.");
+      process.exit(0);
+    }
+    if (shouldSync) {
+      try {
+        const { addedModels, changes } = syncPrismaModels(schemaPath);
+        if (addedModels.length > 0) {
+          p2.log.success(`Mod\xE8les cr\xE9\xE9s : ${addedModels.join(", ")}`);
+        }
+        for (const change of changes) {
+          if (change.action === "added") {
+            p2.log.success(`${change.model}.${change.field} \u2014 ajout\xE9 (${change.detail})`);
+          } else {
+            p2.log.success(`${change.model}.${change.field} \u2014 mis \xE0 jour (${change.detail})`);
+          }
+        }
+        if (addedModels.length === 0 && changes.length === 0) {
+          p2.log.info("Le schema est d\xE9j\xE0 \xE0 jour.");
+        }
+      } catch (error) {
+        p2.log.error(`Erreur : ${error instanceof Error ? error.message : String(error)}`);
+      }
+    }
+  } else {
+    p2.log.warn("Aucun fichier schema.prisma trouv\xE9. Vous devrez ajouter les mod\xE8les manuellement.");
+    p2.log.info("Consultez la documentation : https://github.com/neosianexus/siteping#prisma-schema");
+  }
+  const shouldRoute = await p2.confirm({
+    message: "G\xE9n\xE9rer la route API Next.js App Router ?"
+  });
+  if (p2.isCancel(shouldRoute)) {
+    p2.cancel("Annul\xE9.");
+    process.exit(0);
+  }
+  if (shouldRoute) {
+    try {
+      const { created, path } = generateRoute(cwd);
+      if (created) {
+        p2.log.success(`Route cr\xE9\xE9e : ${path}`);
+      } else {
+        p2.log.info(`La route existe d\xE9j\xE0 : ${path}`);
+      }
+    } catch (error) {
+      p2.log.error(`Erreur : ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+  p2.note(
+    [
+      "1. Ex\xE9cutez : npx prisma db push",
+      "2. Ajoutez le widget dans votre layout :",
+      "",
+      '   import { initSiteping } from "@siteping/widget"',
+      "",
+      "   initSiteping({",
+      '     endpoint: "/api/siteping",',
+      '     projectName: "mon-projet",',
+      "   })"
+    ].join("\n"),
+    "Prochaines \xE9tapes"
+  );
+  p2.outro("Configuration termin\xE9e !");
+}
+function findPrismaSchema(cwd) {
+  const candidates = [
+    join2(cwd, "prisma", "schema.prisma"),
+    join2(cwd, "schema.prisma"),
+    join2(cwd, "prisma", "schema", "schema.prisma")
+  ];
+  return candidates.find((p5) => existsSync3(p5)) ?? null;
+}
+
+// src/commands/status.ts
+import { existsSync as existsSync4, readdirSync, readFileSync as readFileSync2 } from "fs";
+import { join as join3, relative } from "path";
+import * as p3 from "@clack/prompts";
+import { getSchema as getSchema2 } from "@mrleebo/prisma-ast";
+function findPrismaSchema2(cwd) {
+  const candidates = [
+    join3(cwd, "prisma", "schema.prisma"),
+    join3(cwd, "schema.prisma"),
+    join3(cwd, "prisma", "schema", "schema.prisma")
+  ];
+  return candidates.find((c) => existsSync4(c)) ?? null;
+}
+function findApiRoute(cwd) {
+  const candidates = [
+    join3(cwd, "app", "api", "siteping", "route.ts"),
+    join3(cwd, "src", "app", "api", "siteping", "route.ts")
+  ];
+  return candidates.find((c) => existsSync4(c)) ?? null;
+}
+function readPackageJson(cwd) {
+  const pkgPath = join3(cwd, "package.json");
+  if (!existsSync4(pkgPath)) return null;
+  try {
+    return JSON.parse(readFileSync2(pkgPath, "utf-8"));
+  } catch {
+    return null;
+  }
+}
+function findWidgetUsage(cwd) {
+  const searchDirs = [join3(cwd, "src"), join3(cwd, "app"), join3(cwd, "pages")];
+  const extensions = [".ts", ".tsx", ".js", ".jsx"];
+  const patterns = ["initSiteping", "@siteping/widget"];
+  for (const dir of searchDirs) {
+    if (!existsSync4(dir)) continue;
+    const match = searchInDir(dir, extensions, patterns);
+    if (match) return match;
+  }
+  return null;
+}
+function searchInDir(dir, extensions, patterns) {
+  let entries;
+  try {
+    entries = readdirSync(dir, { withFileTypes: true });
+  } catch {
+    return null;
+  }
+  for (const entry of entries) {
+    const name = entry.name;
+    const fullPath = join3(dir, name);
+    if (entry.isDirectory()) {
+      if (name === "node_modules" || name === ".next") continue;
+      const match = searchInDir(fullPath, extensions, patterns);
+      if (match) return match;
+    } else if (extensions.some((ext) => name.endsWith(ext))) {
+      try {
+        const content = readFileSync2(fullPath, "utf-8");
+        if (patterns.some((pat) => content.includes(pat))) return fullPath;
+      } catch {
+      }
+    }
+  }
+  return null;
+}
+function checkSchema(schemaPath) {
+  if (!schemaPath || !existsSync4(schemaPath)) {
+    return { found: false, path: null, missingModels: [], missingFields: [], outdatedFields: [] };
+  }
+  const source = readFileSync2(schemaPath, "utf-8");
+  const schema = getSchema2(source);
+  const existingModels = /* @__PURE__ */ new Map();
+  for (const item of schema.list) {
+    if (item.type === "model") {
+      existingModels.set(item.name, item);
+    }
+  }
+  const missingModels = [];
+  const missingFields = [];
+  const outdatedFields = [];
+  for (const [modelName, modelDef] of Object.entries(SITEPING_MODELS)) {
+    const model = existingModels.get(modelName);
+    if (!model) {
+      missingModels.push(modelName);
+      continue;
+    }
+    const existingFields = /* @__PURE__ */ new Map();
+    for (const prop of model.properties) {
+      if (prop.type === "field") {
+        existingFields.set(prop.name, prop);
+      }
+    }
+    for (const [fieldName, fieldDef] of Object.entries(modelDef.fields)) {
+      const existing = existingFields.get(fieldName);
+      if (!existing) {
+        missingFields.push(`${modelName}.${fieldName}`);
+        continue;
+      }
+      const expectedType = fieldDef.relation ? fieldDef.relation.model : fieldDef.type;
+      const expectedOptional = fieldDef.optional ?? false;
+      const expectedArray = fieldDef.relation?.kind === "1-to-many";
+      const typeMatch = existing.fieldType === expectedType;
+      const optionalMatch = (existing.optional ?? false) === expectedOptional;
+      const arrayMatch = (existing.array ?? false) === expectedArray;
+      if (!typeMatch || !optionalMatch || !arrayMatch) {
+        outdatedFields.push(`${modelName}.${fieldName}`);
+      }
+    }
+  }
+  return { found: true, path: schemaPath, missingModels, missingFields, outdatedFields };
+}
+function pad(label, width) {
+  return label + " ".repeat(Math.max(1, width - label.length));
+}
+function statusCommand(options) {
+  const cwd = process.cwd();
+  p3.intro("siteping \u2014 Diagnostic");
+  const schemaPath = options.schema ?? findPrismaSchema2(cwd);
+  const schemaResult = checkSchema(schemaPath);
+  if (!schemaResult.found) {
+    p3.log.error(`${pad("Prisma schema", 25)}\u2717 Non trouv\xE9`);
+  } else {
+    const issues = [
+      ...schemaResult.missingModels.map((m) => `mod\xE8le ${m}`),
+      ...schemaResult.missingFields,
+      ...schemaResult.outdatedFields
+    ];
+    if (issues.length === 0) {
+      p3.log.success(`${pad("Prisma schema", 25)}\u2713 \xC0 jour`);
+    } else {
+      const missingCount = schemaResult.missingModels.length + schemaResult.missingFields.length;
+      const outdatedCount = schemaResult.outdatedFields.length;
+      const parts = [];
+      if (missingCount > 0)
+        parts.push(`${missingCount} champ${missingCount > 1 ? "s" : ""} manquant${missingCount > 1 ? "s" : ""}`);
+      if (outdatedCount > 0)
+        parts.push(`${outdatedCount} champ${outdatedCount > 1 ? "s" : ""} obsol\xE8te${outdatedCount > 1 ? "s" : ""}`);
+      p3.log.warn(`${pad("Prisma schema", 25)}\u26A0 ${parts.join(", ")} (${issues.join(", ")})`);
+    }
+  }
+  const routePath = findApiRoute(cwd);
+  if (routePath) {
+    p3.log.success(`${pad("Route API", 25)}\u2713 ${relative(cwd, routePath)}`);
+  } else {
+    p3.log.error(`${pad("Route API", 25)}\u2717 Non trouv\xE9e`);
+  }
+  const pkg = readPackageJson(cwd);
+  if (pkg) {
+    const deps = pkg.dependencies ?? {};
+    const devDeps = pkg.devDependencies ?? {};
+    const version = deps["@siteping/widget"] ?? devDeps["@siteping/widget"];
+    if (version) {
+      p3.log.success(`${pad("Package", 25)}\u2713 @siteping/widget@${version}`);
+    } else {
+      p3.log.error(`${pad("Package", 25)}\u2717 @siteping/widget non trouv\xE9 dans package.json`);
+    }
+  } else {
+    p3.log.error(`${pad("Package", 25)}\u2717 package.json non trouv\xE9`);
+  }
+  const widgetFile = findWidgetUsage(cwd);
+  if (widgetFile) {
+    p3.log.success(`${pad("Widget int\xE9gr\xE9", 25)}\u2713 trouv\xE9 dans ${relative(cwd, widgetFile)}`);
+  } else {
+    p3.log.warn(`${pad("Widget int\xE9gr\xE9", 25)}\u26A0 initSiteping non trouv\xE9 dans les sources`);
+  }
+  const hasError = !schemaResult.found || !routePath || !pkg || pkg && !(pkg.dependencies?.["@siteping/widget"] ?? pkg.devDependencies?.["@siteping/widget"]);
+  const hasWarning = schemaResult.missingModels.length > 0 || schemaResult.missingFields.length > 0 || schemaResult.outdatedFields.length > 0 || !widgetFile;
+  if (hasError) {
+    p3.outro("Des \xE9l\xE9ments sont manquants \u2014 lancez `siteping init` pour configurer.");
+  } else if (hasWarning) {
+    p3.outro("Quelques ajustements n\xE9cessaires \u2014 lancez `siteping sync` pour mettre \xE0 jour.");
+  } else {
+    p3.outro("Tout est configur\xE9 !");
+  }
+}
+
+// src/commands/sync.ts
+import { existsSync as existsSync5 } from "fs";
+import { join as join4 } from "path";
+import * as p4 from "@clack/prompts";
+function syncCommand(options) {
+  const cwd = process.cwd();
+  const schemaPath = options.schema ?? findPrismaSchema3(cwd);
+  if (!schemaPath) {
+    p4.log.error("Aucun fichier schema.prisma trouv\xE9.");
+    p4.log.info("Sp\xE9cifiez le chemin avec --schema <path>");
+    process.exit(1);
+  }
+  if (!existsSync5(schemaPath)) {
+    p4.log.error(`Fichier introuvable : ${schemaPath}`);
+    process.exit(1);
+  }
+  try {
+    const { addedModels, changes } = syncPrismaModels(schemaPath);
+    if (addedModels.length === 0 && changes.length === 0) {
+      p4.log.info("\u2713 Le schema est d\xE9j\xE0 \xE0 jour.");
+      return;
+    }
+    if (addedModels.length > 0) {
+      p4.log.success(`Mod\xE8les cr\xE9\xE9s : ${addedModels.join(", ")}`);
+    }
+    for (const change of changes) {
+      const icon = change.action === "added" ? "+" : "~";
+      p4.log.success(
+        `${icon} ${change.model}.${change.field} \u2014 ${change.action === "added" ? "ajout\xE9" : "mis \xE0 jour"} (${change.detail})`
+      );
+    }
+    p4.log.info("N'oubliez pas : npx prisma db push");
+  } catch (error) {
+    p4.log.error(`Erreur : ${error instanceof Error ? error.message : String(error)}`);
+    process.exit(1);
+  }
+}
+function findPrismaSchema3(cwd) {
+  const candidates = [
+    join4(cwd, "prisma", "schema.prisma"),
+    join4(cwd, "schema.prisma"),
+    join4(cwd, "prisma", "schema", "schema.prisma")
+  ];
+  return candidates.find((p5) => existsSync5(p5)) ?? null;
+}
+
+// src/index.ts
+var program = new Command().name("siteping").description("CLI pour configurer @siteping/*").version("0.3.0");
+program.command("init").description("Configure le schema Prisma et la route API dans votre projet").action(initCommand);
+program.command("sync").description("Synchronise le schema Prisma (non-interactif, CI-friendly)").option("--schema <path>", "Chemin vers le fichier schema.prisma").action(syncCommand);
+program.command("status").description("Diagnostic complet de l'int\xE9gration Siteping").option("--schema <path>", "Chemin vers le fichier schema.prisma").action(statusCommand);
+program.command("doctor").description("Test de connexion \xE0 l'API Siteping").option("--url <url>", "URL du serveur (d\xE9faut: http://localhost:3000)").option("--endpoint <path>", "Chemin de l'endpoint (d\xE9faut: /api/siteping)").action(doctorCommand);
+program.parse();

package/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "@siteping/cli",
+  "version": "0.3.0",
+  "description": "CLI pour configurer Siteping dans votre projet",
+  "type": "module",
+  "bin": {
+    "siteping": "./dist/index.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsup",
+    "check": "tsc --noEmit",
+    "clean": "rm -rf dist"
+  },
+  "keywords": [
+    "siteping",
+    "cli",
+    "prisma",
+    "setup"
+  ],
+  "author": "neosianexus",
+  "license": "MIT",
+  "homepage": "https://github.com/NeosiaNexus/siteping/tree/main/packages/cli",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/NeosiaNexus/siteping.git",
+    "directory": "packages/cli"
+  },
+  "dependencies": {
+    "commander": "^13.0.0",
+    "@clack/prompts": "^0.9.0",
+    "@mrleebo/prisma-ast": "^0.12.0"
+  },
+  "devDependencies": {
+    "@siteping/core": "workspace:*"
+  }
+}