create-windy 0.5.0 → 0.5.2

package/dist/cli.js

@@ -2563,15 +2563,25 @@ async function materializeSelectedModules(targetDirectory, selectedNames) {
     ]),
     ...moduleDistributionCatalog.filter(({ databaseLineageOwner }) => databaseLineageOwner === "module").flatMap(({ databaseTables }) => databaseTables)
   ], removed.flatMap(({ databaseStatementTokens }) => databaseStatementTokens));
-  const removedRoots = removed.flatMap((manifest) => [
+  const removedRoots = collapseRemovalRoots(removed.flatMap((manifest) => [
     ...manifest.packages,
     ...manifest.fileRoots,
     ...manifest.documentation,
     ...manifest.schemaFiles
-  ]);
+  ]));
   await Promise.all([...new Set(removedRoots)].map((path) => rm3(join7(targetDirectory, path), { recursive: true, force: true })));
   await pruneWorkspaceReferences(targetDirectory, removedPackageNames, removedRoots);
 }
+function collapseRemovalRoots(paths) {
+  const roots = [];
+  for (const path of [...new Set(paths)].sort((left, right) => left.length - right.length || left.localeCompare(right))) {
+    if (roots.some((root) => path === root || path.startsWith(`${root}/`))) {
+      continue;
+    }
+    roots.push(path);
+  }
+  return roots.sort();
+}
 async function stripModuleBlocks(root, selected) {
   for (const path of await collectFiles2(root)) {
     if (!textExtensions.has(extname(path)))
@@ -2661,16 +2671,27 @@ async function pruneDatabaseArtifacts(root, tableNames, statementTokens) {
     for (const path of await collectFiles2(drizzleRoot)) {
       if (path.endsWith(".sql")) {
         const source = await readFile6(path, "utf8");
-        const statements = source.split("--> statement-breakpoint").map((statement) => statement.trim()).filter(Boolean).filter((statement) => !tablePatterns.some((pattern) => pattern.test(statement)) && !statementTokens.some((token) => statement.includes(token)));
-        await writeFile5(path, statements.length ? `${statements.join(`
+        const statements = source.split("--> statement-breakpoint").map((statement) => statement.trim()).filter(Boolean);
+        const retained = statements.filter((statement) => !tablePatterns.some((pattern) => pattern.test(statement)) && !statementTokens.some((token) => statement.includes(token)));
+        if (retained.length === statements.length)
+          continue;
+        await writeFile5(path, retained.length ? `${retained.join(`
 --> statement-breakpoint
 `)}
 ` : `-- \u6B64 migration \u7684\u6A21\u5757\u672A\u88AB\u5F53\u524D\u9879\u76EE\u9009\u62E9\u3002
 `);
       } else if (path.endsWith("_snapshot.json")) {
         const snapshot = JSON.parse(await readFile6(path, "utf8"));
-        for (const name of tableNames)
-          delete snapshot.tables?.[`public.${name}`];
+        let changed = false;
+        for (const name of tableNames) {
+          const key = `public.${name}`;
+          if (!Object.hasOwn(snapshot.tables ?? {}, key))
+            continue;
+          delete snapshot.tables?.[key];
+          changed = true;
+        }
+        if (!changed)
+          continue;
         await writeFile5(path, `${JSON.stringify(snapshot, null, 2)}
 `);
       }
@@ -7558,6 +7579,16 @@ var recipes = [
     id: "starter-0.4.1-to-0.5.0",
     from: "0.4.1",
     to: "0.5.0"
+  },
+  {
+    id: "starter-0.5.0-to-0.5.1",
+    from: "0.5.0",
+    to: "0.5.1"
+  },
+  {
+    id: "starter-0.5.1-to-0.5.2",
+    from: "0.5.1",
+    to: "0.5.2"
   }
 ];
 function resolveRecipeChain(sourceVersion, targetVersion) {
@@ -8441,6 +8472,146 @@ import { join as join23 } from "path";
 import { mkdtemp as mkdtemp2, rm as rm6, writeFile as writeFile12 } from "fs/promises";
 import { tmpdir as tmpdir2 } from "os";
 import { join as join22 } from "path";
+
+// src/update/merge-convergent-additions.ts
+async function reconcileConvergentAdditions(input) {
+  const [oursDiff, theirsDiff] = await Promise.all([
+    diff(input.root, input.basePath, input.oursPath),
+    diff(input.root, input.basePath, input.theirsPath)
+  ]);
+  if (oursDiff === undefined || theirsDiff === undefined)
+    return;
+  const oursAdditions = pureAdditions(oursDiff);
+  const theirsAdditions = pureAdditions(theirsDiff);
+  const oursByContent = new Map;
+  for (const addition of oursAdditions) {
+    const key = addition.lines.join(`
+`);
+    oursByContent.set(key, [...oursByContent.get(key) ?? [], addition]);
+  }
+  const decode = (content) => new TextDecoder().decode(content);
+  const baseLines = decode(input.base).split(`
+`);
+  const oursLines = decode(input.ours).split(`
+`);
+  const theirsLines = decode(input.theirs).split(`
+`);
+  const mergedLines = input.merged.split(`
+`);
+  const convergent = theirsAdditions.flatMap((addition) => {
+    if (!isSubstantial(addition.lines) || !isNamedClassMethod(addition.lines)) {
+      return [];
+    }
+    const key = addition.lines.join(`
+`);
+    const matchingOurs = oursByContent.get(key);
+    if (matchingOurs?.length !== 1)
+      return [];
+    if (theirsAdditions.filter((candidate2) => candidate2.lines.join(`
+`) === key).length !== 1) {
+      return [];
+    }
+    const oursContainer = enclosingClass(oursLines, matchingOurs[0]);
+    const theirsContainer = enclosingClass(theirsLines, addition);
+    if (!oursContainer || oursContainer !== theirsContainer)
+      return [];
+    return countSequence(baseLines, addition.lines) === 0 && countSequence(oursLines, addition.lines) === 1 && countSequence(theirsLines, addition.lines) === 1 && countSequence(mergedLines, addition.lines) > 1 ? [{ ours: matchingOurs[0], theirs: addition }] : [];
+  });
+  if (convergent.length !== 1)
+    return;
+  const candidate = convergent[0];
+  if (!candidate)
+    return;
+  const oursWithout = withoutAddition(oursLines, candidate.ours);
+  const theirsWithout = withoutAddition(theirsLines, candidate.theirs);
+  if (!oursWithout || !theirsWithout || !sameLines(oursWithout, theirsWithout)) {
+    return;
+  }
+  return input.ours;
+}
+async function diff(root, basePath, branchPath) {
+  const result2 = await captureProcess("git", ["diff", "--no-index", "--unified=0", "--no-color", basePath, branchPath], root);
+  return result2.code === 0 || result2.code === 1 ? result2.stdout : undefined;
+}
+function pureAdditions(diff2) {
+  const lines = diff2.split(`
+`);
+  const additions = [];
+  for (let index = 0;index < lines.length; index += 1) {
+    const match = /^@@ -\d+(?:,(\d+))? \+(\d+)(?:,(\d+))? @@/.exec(lines[index] ?? "");
+    if (!match)
+      continue;
+    const oldCount = match[1] === undefined ? 1 : Number(match[1]);
+    const start = Number(match[2]);
+    const newCount = match[3] === undefined ? 1 : Number(match[3]);
+    if (oldCount !== 0 || newCount === 0)
+      continue;
+    const added = [];
+    for (let cursor = index + 1;cursor < lines.length; cursor += 1) {
+      const line = lines[cursor] ?? "";
+      if (line.startsWith("@@ "))
+        break;
+      if (line.startsWith("+"))
+        added.push(line.slice(1));
+    }
+    if (added.length === newCount)
+      additions.push({ start, lines: added });
+  }
+  return additions;
+}
+function isSubstantial(lines) {
+  return lines.filter((line) => line.trim()).length >= 3 && lines.join(`
+`).length >= 32;
+}
+function isNamedClassMethod(lines) {
+  const first = lines.find((line) => line.trim())?.trim() ?? "";
+  const last = [...lines].reverse().find((line) => line.trim())?.trim() ?? "";
+  return /^(?:(?:public|protected|private|static|abstract|override|async|declare|get|set)\s+)*(?:\*\s*)?[A-Za-z_$][\w$]*\s*(?:<[^>{}]*>)?\s*\(/.test(first) && lines.some((line) => line.includes("{")) && /^}\s*;?$/.test(last);
+}
+function enclosingClass(lines, addition) {
+  const memberIndent = leadingWhitespace(addition.lines.find((line) => line.trim()) ?? "");
+  for (let index = addition.start - 2;index >= 0; index -= 1) {
+    const line = lines[index] ?? "";
+    if (!line.trim() || leadingWhitespace(line) >= memberIndent)
+      continue;
+    const match = /^(\s*)(?:(?:export|default|abstract|declare)\s+)*class\s+([A-Za-z_$][\w$]*)\b/.exec(line);
+    if (!match)
+      return;
+    const name = match[2] ?? "";
+    const ordinal = lines.slice(0, index + 1).filter((candidate) => new RegExp(`^\\s*(?:(?:export|default|abstract|declare)\\s+)*class\\s+${escapeRegExp2(name)}\\b`).test(candidate)).length;
+    return `${name}#${ordinal}`;
+  }
+}
+function leadingWhitespace(line) {
+  return /^\s*/.exec(line)?.[0].length ?? 0;
+}
+function escapeRegExp2(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function countSequence(lines, sequence) {
+  let count = 0;
+  for (let index = 0;index <= lines.length - sequence.length; index += 1) {
+    if (sameLines(lines.slice(index, index + sequence.length), sequence)) {
+      count += 1;
+    }
+  }
+  return count;
+}
+function withoutAddition(lines, addition) {
+  const index = addition.start - 1;
+  if (!sameLines(lines.slice(index, index + addition.lines.length), addition.lines)) {
+    return;
+  }
+  return [
+    ...lines.slice(0, index),
+    ...lines.slice(index + addition.lines.length)
+  ];
+}
+function sameLines(left, right) {
+  return left.length === right.length && left.every((line, index) => line === right[index]);
+}
+
+// src/update/merge.ts
 async function mergeTextFile(base, ours, theirs) {
   const root = await mkdtemp2(join22(tmpdir2(), "windy-merge-"));
   try {
@@ -8454,6 +8625,19 @@ async function mergeTextFile(base, ours, theirs) {
     ]);
     const result2 = await captureProcess("git", ["merge-file", "-p", "--diff3", oursPath, basePath, theirsPath], root);
     if (result2.code === 0) {
+      const reconciledContent = await reconcileConvergentAdditions({
+        root,
+        basePath,
+        oursPath,
+        theirsPath,
+        base,
+        ours,
+        theirs,
+        merged: result2.stdout
+      });
+      if (reconciledContent !== undefined) {
+        return { content: reconciledContent };
+      }
       return { content: new TextEncoder().encode(result2.stdout) };
     }
     if (result2.code === 1) {
@@ -8634,6 +8818,11 @@ function mergeValue(base, ours, theirs, path2, conflicts) {
     return theirs;
   if (equal(theirs, base))
     return ours;
+  if (path2 === "package.json.files") {
+    const files = mergeAppendOnlyStringSet(base, ours, theirs);
+    if (files)
+      return files;
+  }
   if (isObject(base) && isObject(ours) && isObject(theirs)) {
     const output = {};
     const keys = new Set([
@@ -8654,6 +8843,15 @@ function mergeValue(base, ours, theirs, path2, conflicts) {
 function equal(left, right) {
   return JSON.stringify(left) === JSON.stringify(right);
 }
+function mergeAppendOnlyStringSet(base, ours, theirs) {
+  if (!isStringArray(base) || !isStringArray(ours) || !isStringArray(theirs) || !base.every((value) => ours.includes(value) && theirs.includes(value))) {
+    return;
+  }
+  return [...new Set([...ours, ...theirs])].sort();
+}
+function isStringArray(value) {
+  return Array.isArray(value) && value.every((item) => typeof item === "string");
+}
 function isObject(value) {
   return Boolean(value) && typeof value === "object" && !Array.isArray(value);
 }
@@ -8836,6 +9034,33 @@ function resolveModuleRecipeIds(request) {
   return lifecycle.updatedModules.flatMap((name) => catalog.get(name).updateRecipes);
 }
 
+// src/update/planner-project-owned-tests.ts
+var testSuffixes = [
+  ".webtest.ts",
+  ".webtest.tsx",
+  ".test.ts",
+  ".test.tsx"
+];
+var sourceExtensions = [".vue", ".ts", ".tsx", ".js", ".jsx"];
+function preserveTestsForExistingProjectOwnedSources(files, sourceEntries) {
+  const projectOwnedSourcePaths = new Set([...sourceEntries.values()].filter(({ ownership }) => ownership === "project-owned").map(({ path: path2 }) => path2));
+  for (const file of files) {
+    if (file.ownership !== "project-owned" || file.action !== "create" || !hasExistingSourceForTest(file.path, projectOwnedSourcePaths)) {
+      continue;
+    }
+    file.action = "preserve";
+    file.reason = "\u9879\u76EE\u81EA\u6709\u5B9E\u73B0\u5DF2\u5B58\u5728\uFF0C\u4E0D\u65B0\u589E\u4E0A\u6E38\u884C\u4E3A\u6D4B\u8BD5";
+    delete file.content;
+  }
+}
+function hasExistingSourceForTest(path2, sourcePaths) {
+  const suffix = testSuffixes.find((candidate) => path2.endsWith(candidate));
+  if (!suffix)
+    return false;
+  const stem = path2.slice(0, -suffix.length);
+  return sourceExtensions.some((extension) => sourcePaths.has(`${stem}${extension}`));
+}
+
 // src/update/planner-snapshots.ts
 import { readFile as readFile20, stat as stat2 } from "fs/promises";
 import { join as join24 } from "path";
@@ -8995,6 +9220,7 @@ async function createUpdatePlan(request, artifacts) {
     manageGeneratedProjectOwned: request.targetModules !== undefined,
     forcePlatformBaseline: request.forcePlatformBaseline === true
   });
+  preserveTestsForExistingProjectOwnedSources(files, sourceEntries);
   await deriveDockerfilePlans(files, projectSnapshots, new Set([
     ...paths,
     ...workspaceSnapshot.manifests.keys(),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-windy",
-  "version": "0.5.0",
+  "version": "0.5.2",
   "description": "创建单组织、单租户、私有部署优先的 Windy 企业 Dashboard Starter",
   "type": "module",
   "bin": {

package/template/.windy-template.json

@@ -1,7 +1,7 @@
 {
   "schemaVersion": 1,
-  "templateCommit": "647dac095fa843d7c6eaa3e734d3fbf0d80d81d8",
-  "generatorVersion": "0.5.0",
+  "templateCommit": "b4fdd1a323b9445461c149ce93191292283bce6b",
+  "generatorVersion": "0.5.2",
   "modules": [
     {
       "name": "system",

package/template/apps/web/src/pages/system/components/OperationGpuMonitor.vue

@@ -1,7 +1,26 @@
 <script setup lang="ts">
-import type { OperationSnapshot } from "@/services/operations-api";
+interface GpuMonitorSnapshot {
+  status: "available" | "not-detected" | "unavailable";
+  provider: "NVIDIA";
+  message: string;
+  devices: Array<{
+    index: number;
+    uuid: string;
+    name: string;
+    usagePercent: number | null;
+    memoryUsedBytes: number | null;
+    memoryTotalBytes: number | null;
+    memoryUsagePercent: number | null;
+    temperatureCelsius: number | null;
+    processes: Array<{
+      pid: number;
+      name: string;
+      usedMemoryBytes: number | null;
+    }>;
+  }>;
+}
 
-defineProps<{ gpu: OperationSnapshot["gpuMonitor"] }>();
+defineProps<{ gpu: GpuMonitorSnapshot }>();
 
 function formatBytes(value: number | null) {
   if (value === null) return "未知";