@zaip-ai/cli 1.0.7 → 1.0.8

package/templates/.agents/dashboard/apps/frontend/src/project-settings-model.ts

@@ -1,41 +1,123 @@
-import type { ProjectConfigSettings } from "./dashboard-api.js";
+import type { ProjectConfigSettings, ProjectOverview } from "./dashboard-api.js";
 
-export type LanguagesDraft = { frontend: string; backend: string; site: string };
+export const stackComponentDefinitions = [
+  { id: "primary_language", defaultName: "TypeScript", scope: "backend" },
+  { id: "backend_runtime", defaultName: "Node.js", scope: "backend" },
+  { id: "backend_api", defaultName: "Hono", scope: "backend" },
+  { id: "query_builder", defaultName: "Kysely", scope: "backend" },
+  { id: "database", defaultName: "PostgreSQL via Supabase", scope: "backend" },
+  { id: "auth_storage", defaultName: "Supabase Auth + Storage", scope: "backend" },
+  { id: "cache_messaging", defaultName: "Redis", scope: "backend" },
+  { id: "async_queue", defaultName: "BullMQ", scope: "backend" },
+  { id: "backend_infrastructure", defaultName: "Hostinger VPS", scope: "backend" },
+  { id: "web_framework", defaultName: "React", scope: "frontend" },
+  { id: "web_language", defaultName: "TypeScript", scope: "frontend" },
+  { id: "web_build", defaultName: "Vite", scope: "frontend" },
+  { id: "frontend_hosting", defaultName: "Cloudflare Pages", scope: "frontend" },
+  { id: "site_framework", defaultName: "Astro", scope: "site" },
+  { id: "site_language", defaultName: "TypeScript", scope: "site" },
+  { id: "site_islands", defaultName: "React Islands", scope: "site" },
+  { id: "site_build", defaultName: "Vite", scope: "site" },
+  { id: "site_hosting", defaultName: "Cloudflare Pages", scope: "site" },
+] as const;
+
+export type StackComponentId = (typeof stackComponentDefinitions)[number]["id"];
+export type StackComponentDraft = { name: string; version: string; reference: string };
+export type StackComponentsDraft = Record<StackComponentId, StackComponentDraft>;
 
 export function projectSettingsDraft(config: ProjectConfigSettings): {
-  languages: LanguagesDraft;
+  components: StackComponentsDraft;
   otherOverrides: string;
 } {
-  const { languages: rawLanguages, ...otherOverrides } = config.stack.overrides;
-  const languageMap = isRecord(rawLanguages) ? rawLanguages : {};
+  const {
+    languages: _languages,
+    components: rawComponents,
+    ...otherOverrides
+  } = config.stack.overrides;
+  const componentMap = isRecord(rawComponents) ? rawComponents : {};
   return {
-    languages: {
-      frontend: languageText(languageMap.frontend),
-      backend: languageText(languageMap.backend),
-      site: languageText(languageMap.site),
-    },
+    components: Object.fromEntries(
+      stackComponentDefinitions.map((definition) => {
+        const rawValue = componentMap[definition.id];
+        const value: Record<string, unknown> = isRecord(rawValue) ? rawValue : {};
+        return [
+          definition.id,
+          {
+            name: stringValue(value.name) || definition.defaultName,
+            version: stringValue(value.version),
+            reference: stringValue(value.reference),
+          },
+        ];
+      }),
+    ) as StackComponentsDraft,
     otherOverrides: JSON.stringify(otherOverrides, null, 2),
   };
 }
 
+export function withDetectedStackVersions(
+  components: StackComponentsDraft,
+  detected: ProjectOverview["stack_components"],
+): StackComponentsDraft {
+  const versions = new Map(
+    detected
+      .filter((component) => component.verification === "exact" && component.version !== null)
+      .map((component) => [component.name.toLowerCase(), component.version as string]),
+  );
+  return Object.fromEntries(
+    stackComponentDefinitions.map((definition) => {
+      const current = components[definition.id];
+      const detectedVersion = versions.get(detectionName(definition.id));
+      return [
+        definition.id,
+        current.version !== "" || detectedVersion === undefined
+          ? current
+          : { ...current, version: detectedVersion },
+      ];
+    }),
+  ) as StackComponentsDraft;
+}
+
 export function buildProjectSettingsPayload(
   config: ProjectConfigSettings,
-  languages: LanguagesDraft,
+  components: StackComponentsDraft,
   otherOverridesSource: string,
 ): ProjectConfigSettings {
   const parsed = JSON.parse(otherOverridesSource) as unknown;
   if (!isRecord(parsed)) throw new Error("Demais overrides deve ser um objeto JSON.");
-  const { languages: _ignoredLanguages, ...otherOverrides } = parsed;
+  const {
+    languages: _ignoredLanguages,
+    components: _ignoredComponents,
+    ...otherOverrides
+  } = parsed;
+  for (const definition of stackComponentDefinitions) {
+    const version = components[definition.id].version.trim();
+    if (version !== "" && !/^\d+\.\d+(?:\.\d+)?(?:[-+][0-9A-Za-z.-]+)?$/.test(version)) {
+      throw new Error(
+        `A versão de ${components[definition.id].name || definition.defaultName} deve ser exata, como 22.16.0 ou 17.6, sem ^, ~, >= ou latest.`,
+      );
+    }
+  }
+  const normalized = Object.fromEntries(
+    stackComponentDefinitions.map((definition) => [
+      definition.id,
+      {
+        name: components[definition.id].name.trim() || definition.defaultName,
+        version: components[definition.id].version.trim(),
+        reference: components[definition.id].reference.trim(),
+      },
+    ]),
+  ) as StackComponentsDraft;
   return {
     ...config,
     stack: {
       ...config.stack,
       overrides: {
         ...otherOverrides,
+        components: normalized,
         languages: {
-          frontend: commaList(languages.frontend),
-          backend: commaList(languages.backend),
-          site: commaList(languages.site),
+          frontend: componentNames(normalized, "frontend"),
+          backend: componentNames(normalized, "backend"),
+          site: componentNames(normalized, "site"),
         },
       },
     },
@@ -53,46 +135,6 @@ export function lineList(value: string): string[] {
   ];
 }
 
-export function defaultModelOrchestration(): NonNullable<
-  ProjectConfigSettings["model_orchestration"]
-> {
-  return modelOrchestrationForMode("auto");
-}
-
-export function modelOrchestrationForMode(
-  mode: "manual" | "off" | "auto",
-): NonNullable<ProjectConfigSettings["model_orchestration"]> {
-  if (mode === "manual") {
-    return {
-      mode,
-      default_model: "manual",
-      default_effort: "manual",
-      default_velocity: "manual",
-      notice: "mismatch",
-    };
-  }
-  if (mode === "off") {
-    return {
-      mode,
-      default_model: "gpt-5.6-terra",
-      default_effort: "medium",
-      default_velocity: "standard",
-      notice: "mismatch",
-    };
-  }
-  return {
-    mode,
-    default_model: "gpt-5.6-terra",
-    default_effort: "medium",
-    default_velocity: "standard",
-    allowed_models: ["gpt-5.6-luna", "gpt-5.6-terra", "gpt-5.6-sol"],
-    allowed_efforts: ["low", "medium", "high", "xhigh"],
-    max_auto_effort: "xhigh",
-    automatic_sources: ["spec", "prd"],
-    notice: "mismatch",
-  };
-}
-
 export function defaultAutonomousExecution(): Extract<
   NonNullable<ProjectConfigSettings["execution"]>,
   { runtime: "autonomous" }
@@ -108,22 +150,39 @@ export function defaultAutonomousExecution(): Extract<
   };
 }
 
-function languageText(value: unknown): string {
-  if (Array.isArray(value)) return value.filter((item) => typeof item === "string").join(", ");
-  return typeof value === "string" ? value : "";
+export function shortFrameworkVersion(version: string | null | undefined): string | null {
+  const match = version?.match(/^v?(\d+)\.(\d+)\.\d+(?:[-+][0-9A-Za-z.-]+)?$/);
+  return match ? `v${match[1]}.${match[2]}` : null;
+}
+
+function detectionName(id: StackComponentId): string {
+  if (id === "backend_runtime") return "node.js";
+  if (id === "backend_api") return "hono";
+  if (id === "site_framework") return "astro";
+  if (id === "cache_messaging") return "redis";
+  if (id === "async_queue") return "bullmq";
+  if (id === "web_framework" || id === "site_islands") return "react";
+  if (id === "web_build" || id === "site_build") return "vite";
+  if (id === "primary_language" || id === "web_language" || id === "site_language")
+    return "typescript";
+  return "";
 }
 
-function commaList(value: string): string[] {
+function componentNames(components: StackComponentsDraft, scope: "frontend" | "backend" | "site") {
   return [
     ...new Set(
-      value
-        .split(",")
-        .map((item) => item.trim())
+      stackComponentDefinitions
+        .filter((definition) => definition.scope === scope)
+        .map((definition) => components[definition.id].name.trim())
         .filter(Boolean),
     ),
   ];
 }
 
+function stringValue(value: unknown): string {
+  return typeof value === "string" ? value : "";
+}
+
 function isRecord(value: unknown): value is Record<string, unknown> {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }