@nuucognition/flint-cli 0.3.0-alpha.1 → 0.4.0-alpha.0

package/dist/chunk-JNF2DSZM.js

@@ -0,0 +1,243 @@
+import {
+  getMeshExportSources,
+  getSourceRepositories,
+  nameFormats
+} from "./chunk-GQSLJAUU.js";
+
+// ../../packages/flint/dist/chunk-Q3TNNVO6.js
+import { readFile, writeFile, mkdir, stat, readdir, unlink } from "fs/promises";
+import { join } from "path";
+import { randomUUID } from "crypto";
+function getMetadataDir(flintPath) {
+  return join(flintPath, "Mesh", "Metadata");
+}
+function getSourcesMetadataDir(flintPath) {
+  return join(getMetadataDir(flintPath), "Sources");
+}
+async function fileExists(path) {
+  try {
+    await stat(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function extractId(content) {
+  const match = content.match(/^id:\s*(.+)$/m);
+  return match?.[1]?.trim() || null;
+}
+function extractNotesSection(content) {
+  const body = content.replace(/^---\n[\s\S]*?\n---\n*/, "").trim();
+  const idx = body.indexOf("## Notes");
+  if (idx === -1) return null;
+  return body.substring(idx).trim();
+}
+async function syncMetadataFile(filePath, buildContent) {
+  let existingId = null;
+  let existingNotes = null;
+  if (await fileExists(filePath)) {
+    const existing = await readFile(filePath, "utf-8");
+    existingId = extractId(existing);
+    existingNotes = extractNotesSection(existing);
+  }
+  const id = existingId || randomUUID();
+  const notes = existingNotes || "## Notes\n\n(Add notes here)";
+  const newContent = buildContent(id, notes);
+  if (existingId) {
+    const existing = await readFile(filePath, "utf-8");
+    if (existing === newContent) {
+      return "synced";
+    }
+  }
+  await writeFile(filePath, newContent);
+  return existingId ? "synced" : "created";
+}
+function getSourceMeshExportDir(flintPath) {
+  return join(getSourcesMetadataDir(flintPath), "Mesh Exports");
+}
+function getSourceMeshExportPath(flintPath, ref) {
+  const parts = ref.split("/");
+  const flintName = parts[0] || ref;
+  const exportName = parts[1] || "";
+  const flintSnake = nameFormats(flintName).snake;
+  const exportSnake = nameFormats(exportName).snake;
+  return join(getSourceMeshExportDir(flintPath), `src-me-${flintSnake}-${exportSnake}.md`);
+}
+function buildMeshExportContent(ref, id, notes) {
+  return `---
+id: ${id}
+tags:
+  - "#f/metadata"
+  - "#f/source"
+type: flint-mesh
+---
+
+Execute \`flint resolve source "${ref}"\` to get the local path.
+
+${notes}
+`;
+}
+async function generateSourceMeshExportMetadata(flintPath, ref) {
+  const filePath = getSourceMeshExportPath(flintPath, ref);
+  await mkdir(getSourceMeshExportDir(flintPath), { recursive: true });
+  const result = await syncMetadataFile(
+    filePath,
+    (id, notes) => buildMeshExportContent(ref, id, notes)
+  );
+  return result === "created";
+}
+async function removeSourceMeshExportMetadata(flintPath, ref) {
+  const filePath = getSourceMeshExportPath(flintPath, ref);
+  try {
+    await unlink(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function syncSourceMeshExportMetadata(flintPath) {
+  await mkdir(getSourceMeshExportDir(flintPath), { recursive: true });
+  const meshexports = await getMeshExportSources(flintPath);
+  const created = [];
+  const unchanged = [];
+  const removed = [];
+  for (const ref of meshexports) {
+    const changed = await generateSourceMeshExportMetadata(flintPath, ref);
+    const parts = ref.split("/");
+    const flintSnake = nameFormats(parts[0] || "").snake;
+    const exportSnake = nameFormats(parts[1] || "").snake;
+    const key = `src-me-${flintSnake}-${exportSnake}`;
+    if (changed) {
+      created.push(key);
+    } else {
+      unchanged.push(key);
+    }
+  }
+  try {
+    const dir = getSourceMeshExportDir(flintPath);
+    const files = await readdir(dir);
+    const declaredFiles = new Set(
+      meshexports.map((ref) => {
+        const parts = ref.split("/");
+        const flintSnake = nameFormats(parts[0] || "").snake;
+        const exportSnake = nameFormats(parts[1] || "").snake;
+        return `src-me-${flintSnake}-${exportSnake}.md`;
+      })
+    );
+    for (const file of files) {
+      if (file.startsWith("src-me-") && !declaredFiles.has(file)) {
+        await unlink(join(dir, file)).catch(() => {
+        });
+        removed.push(file.replace(".md", ""));
+      }
+    }
+  } catch {
+  }
+  return { created, removed, unchanged };
+}
+function getSourceRepoMetadataDir(flintPath) {
+  return join(getSourcesMetadataDir(flintPath), "Repos");
+}
+function getSourceRepoMetadataPath(flintPath, name) {
+  const { snake } = nameFormats(name);
+  return join(getSourceRepoMetadataDir(flintPath), `src-repo-${snake}.md`);
+}
+function buildSourceRepoContent(name, url, id, notes) {
+  return `---
+id: ${id}
+tags:
+  - "#f/metadata"
+  - "#f/source-repo"
+type: source-repo
+---
+
+Source repository: **${name}**
+URL: ${url}
+
+${notes}
+`;
+}
+async function generateSourceRepoMetadata(flintPath, name, url) {
+  const filePath = getSourceRepoMetadataPath(flintPath, name);
+  await mkdir(getSourceRepoMetadataDir(flintPath), { recursive: true });
+  const result = await syncMetadataFile(
+    filePath,
+    (id, notes) => buildSourceRepoContent(name, url, id, notes)
+  );
+  return result === "created";
+}
+async function removeSourceRepoMetadata(flintPath, name) {
+  const filePath = getSourceRepoMetadataPath(flintPath, name);
+  try {
+    await unlink(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function syncSourceRepoMetadata(flintPath) {
+  await mkdir(getSourceRepoMetadataDir(flintPath), { recursive: true });
+  const declarations = await getSourceRepositories(flintPath);
+  const created = [];
+  const unchanged = [];
+  const removed = [];
+  for (const decl of declarations) {
+    const changed = await generateSourceRepoMetadata(flintPath, decl.name, decl.url);
+    const key = `src-repo-${nameFormats(decl.name).snake}`;
+    if (changed) {
+      created.push(key);
+    } else {
+      unchanged.push(key);
+    }
+  }
+  try {
+    const dir = getSourceRepoMetadataDir(flintPath);
+    const files = await readdir(dir);
+    const declaredSnakes = new Set(
+      declarations.map((d) => `src-repo-${nameFormats(d.name).snake}.md`)
+    );
+    for (const file of files) {
+      if (file.startsWith("src-repo-") && !declaredSnakes.has(file)) {
+        await unlink(join(dir, file)).catch(() => {
+        });
+        removed.push(file.replace(".md", ""));
+      }
+    }
+  } catch {
+  }
+  return { created, removed, unchanged };
+}
+async function resolveSource(flintPath, ref) {
+  const parts = ref.split("/");
+  const flintName = parts[0] || ref;
+  const exportName = parts[1] || "";
+  const sourcePath = join(flintPath, "Sources", "Flints", `(Flint) ${flintName}`, `(Mesh Export) ${exportName}`);
+  try {
+    await stat(sourcePath);
+    return { status: "fulfilled", name: ref, type: "flint-mesh", path: sourcePath };
+  } catch {
+    return { status: "unfulfilled", name: ref, type: "flint-mesh", path: sourcePath };
+  }
+}
+async function ensureMetadataDirs(flintPath) {
+  await mkdir(getSourcesMetadataDir(flintPath), { recursive: true });
+  await mkdir(getSourceRepoMetadataDir(flintPath), { recursive: true });
+  await mkdir(getSourceMeshExportDir(flintPath), { recursive: true });
+}
+
+export {
+  getMetadataDir,
+  getSourcesMetadataDir,
+  getSourceMeshExportDir,
+  getSourceMeshExportPath,
+  generateSourceMeshExportMetadata,
+  removeSourceMeshExportMetadata,
+  syncSourceMeshExportMetadata,
+  getSourceRepoMetadataDir,
+  getSourceRepoMetadataPath,
+  generateSourceRepoMetadata,
+  removeSourceRepoMetadata,
+  syncSourceRepoMetadata,
+  resolveSource,
+  ensureMetadataDirs
+};

package/dist/{chunk-OIXBMYAA.js → chunk-NFM75BMP.js}

@@ -1,4 +1,4 @@
-// ../../packages/flint/dist/chunk-X3YVJP3U.js
+// ../../packages/flint/dist/chunk-JGOCUBLW.js
 import { mkdir, readFile, writeFile } from "fs/promises";
 import { homedir } from "os";
 import { join, resolve } from "path";
@@ -182,7 +182,7 @@ async function cleanRegistryFile() {
   return result;
 }
 async function registerFlintByPath(path, options) {
-  const { readFlintToml, hasFlintToml } = await import("./mesh-config-7GOTOVCM-TZEJ43E5.js");
+  const { readFlintToml, hasFlintToml } = await import("./mesh-config-TEPKR6QZ-TINWSM6H.js");
   const isFlint = await hasFlintToml(path);
   if (!isFlint) {
     throw new Error(`Not a valid flint: ${path}
@@ -197,6 +197,10 @@ Missing flint.toml`);
   if (existing && !options?.force) {
     throw new Error(`Already registered: "${existing.name}" at ${path}`);
   }
+  const nameTaken = await isFlintNameTaken(name);
+  if (nameTaken && resolve(nameTaken.path) !== resolve(path)) {
+    throw new Error(`Name "${name}" is already taken by a flint at ${nameTaken.path}`);
+  }
   const entry = {
     name,
     path,