@nuucognition/flint-cli 0.2.0-beta.0 → 0.2.0-beta.2

package/bin/flint-prod.js

@@ -1,7 +1,9 @@
 #!/usr/bin/env node
 
-import { fileURLToPath } from 'node:url';
+process.env.BUILD_MODE = 'prod';
+
+import { fileURLToPath, pathToFileURL } from 'node:url';
 import { dirname, join } from 'node:path';
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
-await import(join(__dirname, '..', 'dist', 'index.js'));
+await import(pathToFileURL(join(__dirname, '..', 'dist', 'index.js')).href);

package/dist/{chunk-BVYUS7NX.js → chunk-K5QP4OME.js}

@@ -1,4 +1,4 @@
-// ../../packages/flint/src/exports.ts
+// ../../packages/flint/dist/chunk-CKCIJQXP.js
 import { readdir, readFile, mkdir, writeFile, rm, stat } from "fs/promises";
 import { join, basename, dirname, resolve, relative, sep } from "path";
 async function exists(path) {
@@ -224,6 +224,31 @@ function getDisambiguatedExportName(flintPath, sourcePath, baseName) {
   return `${baseName} (${dirLabel})`;
 }
 async function scanExports(flintPath) {
+  const { readFlintToml } = await import("./mesh-config-J6WB4RFV-G7RGPOZA.js");
+  const config = await readFlintToml(flintPath);
+  const declarations = config?.exports?.required;
+  if (declarations && declarations.length > 0) {
+    return scanExportsFromConfig(flintPath, declarations);
+  }
+  return scanExportsLegacy(flintPath);
+}
+async function scanExportsFromConfig(flintPath, declarations) {
+  const manifests = [];
+  for (const decl of declarations) {
+    const sourcePath = await resolveDocument(decl.file.replace(/\.md$/, ""), flintPath);
+    if (!sourcePath) continue;
+    try {
+      const content = await readFile(sourcePath, "utf-8");
+      const depth = decl.depth ?? (decl.mode === "mesh" ? 1 : 1);
+      const manifest = parseExportDocument(content, decl.name, sourcePath);
+      manifest.depth = depth;
+      manifests.push(manifest);
+    } catch {
+    }
+  }
+  return manifests;
+}
+async function scanExportsLegacy(flintPath) {
   const meshDir = join(flintPath, "Mesh");
   if (!await exists(meshDir)) {
     return [];
@@ -242,9 +267,49 @@ async function scanExports(flintPath) {
   }
   return manifests;
 }
+async function scanExportEligible(flintPath) {
+  const meshDir = join(flintPath, "Mesh");
+  if (!await exists(meshDir)) return [];
+  const { readFlintToml } = await import("./mesh-config-J6WB4RFV-G7RGPOZA.js");
+  const config = await readFlintToml(flintPath);
+  const declared = new Set(
+    (config?.exports?.required || []).map((d) => d.file.replace(/\.md$/, "").toLowerCase())
+  );
+  const eligible = [];
+  await findExportTaggedFiles(meshDir, flintPath, declared, eligible);
+  return eligible;
+}
+async function findExportTaggedFiles(dir, flintPath, declared, results) {
+  try {
+    const entries = await readdir(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      const fullPath = join(dir, entry.name);
+      if (entry.isDirectory()) {
+        await findExportTaggedFiles(fullPath, flintPath, declared, results);
+      } else if (entry.isFile() && entry.name.endsWith(".md")) {
+        try {
+          const content = await readFile(fullPath, "utf-8");
+          const fmMatch = content.match(/^---\n([\s\S]*?)\n---/);
+          if (!fmMatch || !fmMatch[1]) continue;
+          const hasExportTag = /["']#export["']/.test(fmMatch[1]);
+          if (!hasExportTag) continue;
+          const fileName = basename(fullPath, ".md");
+          if (declared.has(fileName.toLowerCase())) continue;
+          results.push({
+            filePath: fullPath,
+            fileName: entry.name,
+            name: fileName
+          });
+        } catch {
+        }
+      }
+    }
+  } catch {
+  }
+}
 async function buildExport(manifest, flintPath) {
   const exportsDir = join(flintPath, "Exports");
-  const outputDir = join(exportsDir, manifest.name);
+  const outputDir = join(exportsDir, `(Mesh) ${manifest.name}`);
   if (await exists(outputDir)) {
     await rm(outputDir, { recursive: true });
   }
@@ -254,13 +319,15 @@ async function buildExport(manifest, flintPath) {
   const resolvedFiles = [];
   const processedPaths = /* @__PURE__ */ new Set();
   processedPaths.add(manifest.sourcePath);
-  for (const docRef of manifest.files) {
-    const sourcePath = await resolveDocument(docRef, flintPath);
-    if (!sourcePath || processedPaths.has(sourcePath)) continue;
-    resolvedFiles.push({ sourcePath, docRef });
-    processedPaths.add(sourcePath);
-  }
   const depth = manifest.depth;
+  if (depth === -1 || depth > 0) {
+    for (const docRef of manifest.files) {
+      const sourcePath = await resolveDocument(docRef, flintPath);
+      if (!sourcePath || processedPaths.has(sourcePath)) continue;
+      resolvedFiles.push({ sourcePath, docRef });
+      processedPaths.add(sourcePath);
+    }
+  }
   const allReferencedFiles = /* @__PURE__ */ new Set();
   const exportContent = await readFile(manifest.sourcePath, "utf-8");
   await collectReferencedFiles(exportContent, flintPath, allReferencedFiles, new Set(processedPaths), depth, 0);
@@ -275,7 +342,7 @@ async function buildExport(manifest, flintPath) {
     }
   }
   const allExportFiles = [
-    { sourcePath: manifest.sourcePath, baseName: manifest.name },
+    { sourcePath: manifest.sourcePath, baseName: basename(manifest.sourcePath, ".md") },
     ...resolvedFiles.map((f) => ({ sourcePath: f.sourcePath, baseName: basename(f.sourcePath, ".md") }))
   ];
   const baseNameCounts = /* @__PURE__ */ new Map();
@@ -317,6 +384,7 @@ async function buildExport(manifest, flintPath) {
   const manifestJson = {
     name: manifest.name,
     flint: flintName,
+    rootFile: rootFileName,
     builtAt: (/* @__PURE__ */ new Date()).toISOString(),
     files: copiedFiles
   };
@@ -345,11 +413,12 @@ async function cleanupStaleExports(flintPath) {
     return removed;
   }
   const manifests = await scanExports(flintPath);
-  const validExportNames = new Set(manifests.map((m) => m.name));
+  const validFolderNames = new Set(manifests.map((m) => `(Mesh) ${m.name}`));
+  const validLegacyNames = new Set(manifests.map((m) => m.name));
   const entries = await readdir(exportsDir, { withFileTypes: true });
   for (const entry of entries) {
     if (entry.isDirectory()) {
-      if (!validExportNames.has(entry.name)) {
+      if (!validFolderNames.has(entry.name) && !validLegacyNames.has(entry.name)) {
         try {
           await rm(join(exportsDir, entry.name), { recursive: true });
           removed.push(entry.name);
@@ -379,6 +448,7 @@ async function buildAllExports(flintPath) {
 
 export {
   scanExports,
+  scanExportEligible,
   buildExport,
   buildExportByName,
   cleanupStaleExports,

package/dist/{chunk-EICASOEX.js → chunk-RAH2IR2Z.js}

@@ -1,4 +1,4 @@
-// ../../packages/flint/src/mesh-config.ts
+// ../../packages/flint/dist/chunk-2WZYXQX5.js
 import { readFile, writeFile, stat } from "fs/promises";
 import { join } from "path";
 
@@ -828,8 +828,15 @@ function stringify(obj, { maxDepth = 1e3, numbersAsFloat = false } = {}) {
   return str;
 }
 
-// ../../packages/flint/src/mesh-config.ts
+// ../../packages/flint/dist/chunk-2WZYXQX5.js
 import { randomUUID } from "crypto";
+function resolveShardMode(decl) {
+  return decl.mode;
+}
+function isLocalShard(decl) {
+  const mode = resolveShardMode(decl);
+  return mode === "dev" || mode === "custom";
+}
 var FLINT_CONFIG_FILENAME = "flint.toml";
 var FLINT_JSON_FILENAME = "flint.json";
 var FLINT_VERSION = "0.2.0";
@@ -964,26 +971,49 @@ async function readFlintToml(flintPath) {
     throw error;
   }
 }
+function tv(v) {
+  if (typeof v === "string") return `"${v}"`;
+  if (typeof v === "boolean") return v ? "true" : "false";
+  if (typeof v === "number") return String(v);
+  if (Array.isArray(v)) return `[${v.map(tv).join(", ")}]`;
+  return String(v);
+}
+function inlineTable(obj) {
+  const parts = Object.entries(obj).filter(([, v]) => v !== void 0 && v !== null).map(([k, v]) => `${k} = ${tv(v)}`);
+  return `{ ${parts.join(", ")} }`;
+}
+function inlineTableArray(items) {
+  return [
+    "[",
+    ...items.map((item) => `  ${inlineTable(item)},`),
+    "]"
+  ];
+}
+function stringArray(items) {
+  return [
+    "[",
+    ...items.map((s) => `  "${s}",`),
+    "]"
+  ];
+}
 function formatFlintToml(config) {
   const lines = [];
   lines.push("[flint]");
-  lines.push(`name = "${config.flint.name}"`);
-  if (config.flint.type) {
-    lines.push(`type = "${config.flint.type}"`);
-  }
-  if (config.flint.description) {
-    lines.push(`description = "${config.flint.description}"`);
-  }
-  if (config.flint.tags && config.flint.tags.length > 0) {
-    lines.push(`tags = [${config.flint.tags.map((t) => `"${t}"`).join(", ")}]`);
-  }
+  lines.push(`name = ${tv(config.flint.name)}`);
+  if (config.flint.type) lines.push(`type = ${tv(config.flint.type)}`);
+  if (config.flint.description) lines.push(`description = ${tv(config.flint.description)}`);
+  if (config.flint.tags?.length) lines.push(`tags = ${tv(config.flint.tags)}`);
+  if (config.flint.org) lines.push(`org = ${tv(config.flint.org)}`);
   lines.push("");
   if (config.shards) {
     const declarations = getShardDeclarationsFromConfig(config);
     if (Object.keys(declarations).length > 0) {
       lines.push("[shards]");
       for (const [shorthand, decl] of Object.entries(declarations)) {
-        lines.push(`${shorthand} = { source = "${decl.source}"${decl.dev ? ", dev = true" : ""} }`);
+        const mode = resolveShardMode(decl);
+        const fields = { source: decl.source };
+        if (mode) fields.mode = mode;
+        lines.push(`${shorthand} = ${inlineTable(fields)}`);
       }
       lines.push("");
     }
@@ -993,68 +1023,70 @@ function formatFlintToml(config) {
     if (Object.keys(modDeclarations).length > 0) {
       lines.push("[mods]");
       for (const [name, decl] of Object.entries(modDeclarations)) {
-        lines.push(`${name} = { source = "${decl.source}"${decl.dev ? ", dev = true" : ""} }`);
+        const fields = { source: decl.source };
+        if (decl.dev) fields.dev = true;
+        lines.push(`${name} = ${inlineTable(fields)}`);
       }
       lines.push("");
     }
   }
-  if (config.imports?.required && config.imports.required.length > 0) {
+  if (config.exports?.required?.length) {
+    lines.push("[exports]");
+    const items = config.exports.required.map((e) => {
+      const fields = { name: e.name, file: e.file, mode: e.mode };
+      if (e.depth !== void 0 && e.depth !== 1) fields.depth = e.depth;
+      return fields;
+    });
+    lines.push(`required = ${inlineTableArray(items).join("\n")}`);
+    lines.push("");
+  }
+  const flintImports = config.imports?.flints || config.imports?.required || [];
+  if (flintImports.length) {
     lines.push("[imports]");
-    lines.push("required = [");
-    for (const ref of config.imports.required) {
-      lines.push(`  "${ref}",`);
-    }
-    lines.push("]");
+    lines.push(`flints = ${stringArray(flintImports).join("\n")}`);
     lines.push("");
   }
-  const hasReferences = config.workspace?.references && config.workspace.references.length > 0;
-  const hasRepositories = config.workspace?.repositories && config.workspace.repositories.length > 0;
-  const hasSourceRepositories = config.workspace?.sources?.repositories && config.workspace.sources.repositories.length > 0;
-  if (hasReferences || hasRepositories || hasSourceRepositories) {
+  const hasRefs = config.workspace?.references?.length;
+  const hasRepos = config.workspace?.repositories?.length;
+  const hasSrcRepos = config.workspace?.sources?.repositories?.length;
+  if (hasRefs || hasRepos) {
     lines.push("[workspace]");
-    if (hasReferences) {
-      lines.push("references = [");
-      for (const ref of config.workspace.references) {
-        lines.push(`  { name = "${ref.name}", type = "${ref.type}" },`);
-      }
-      lines.push("]");
+    if (hasRefs) {
+      const items = config.workspace.references.map((r) => ({ name: r.name, type: r.type }));
+      lines.push(`references = ${inlineTableArray(items).join("\n")}`);
     }
-    if (hasRepositories) {
-      lines.push("repositories = [");
-      for (const repo of config.workspace.repositories) {
-        lines.push(`  { name = "${repo.name}", url = "${repo.url}" },`);
-      }
-      lines.push("]");
+    if (hasRepos) {
+      const items = config.workspace.repositories.map((r) => ({ name: r.name, url: r.url }));
+      lines.push(`repositories = ${inlineTableArray(items).join("\n")}`);
     }
     lines.push("");
   }
-  if (hasSourceRepositories) {
+  if (hasSrcRepos) {
     lines.push("[workspace.sources]");
-    lines.push("repositories = [");
-    for (const repo of config.workspace.sources.repositories) {
-      lines.push(`  { name = "${repo.name}", url = "${repo.url}" },`);
-    }
-    lines.push("]");
+    const items = config.workspace.sources.repositories.map((r) => ({ name: r.name, url: r.url }));
+    lines.push(`repositories = ${inlineTableArray(items).join("\n")}`);
     lines.push("");
   }
-  if (config.connections?.flints && config.connections.flints.length > 0) {
+  if (config.connections?.flints?.length) {
     lines.push("[connections]");
-    lines.push("flints = [");
-    for (const conn of config.connections.flints) {
-      lines.push(`  { name = "${conn.name}" },`);
-    }
-    lines.push("]");
+    const items = config.connections.flints.map((c) => ({ name: c.name }));
+    lines.push(`flints = ${inlineTableArray(items).join("\n")}`);
+    lines.push("");
+  }
+  if (config.git?.remote) {
+    lines.push("[git]");
+    lines.push(`remote = ${tv(config.git.remote)}`);
     lines.push("");
   }
-  if (config.lattices && config.lattices.length > 0) {
+  if (config.lattices?.length) {
     for (const lattice of config.lattices) {
       lines.push("[[lattices]]");
-      lines.push(`name = "${lattice.name}"`);
-      lines.push(`path = "${lattice.path}"`);
+      lines.push(`name = ${tv(lattice.name)}`);
+      lines.push(`path = ${tv(lattice.path)}`);
       lines.push("");
     }
   }
-  const knownKeys = /* @__PURE__ */ new Set(["flint", "shards", "mods", "imports", "workspace", "connections", "lattices"]);
+  const knownKeys = /* @__PURE__ */ new Set(["flint", "shards", "mods", "exports", "imports", "workspace", "connections", "git", "lattices"]);
   const unknownKeys = Object.keys(config).filter((k) => !knownKeys.has(k));
   if (unknownKeys.length > 0) {
     const unknownConfig = {};
@@ -1089,7 +1121,7 @@ async function addShardToConfig(flintPath, shardName, source, options = {}) {
   const effectiveSource = source || kebabName;
   if (!existing || existing.source !== effectiveSource) {
     const decl = { source: effectiveSource };
-    if (options.dev) decl.dev = true;
+    if (options.mode) decl.mode = options.mode;
     config.shards[kebabName] = decl;
     await writeFlintToml(flintPath, config);
   }
@@ -1378,56 +1410,100 @@ async function getLatticeReference(flintPath, name) {
   const normalizedName = name.toLowerCase();
   return config?.lattices?.find((entry) => entry.name.toLowerCase() === normalizedName) || null;
 }
-async function addImportToConfig(flintPath, ref) {
+async function addExportToConfig(flintPath, declaration) {
   let config = await readFlintToml(flintPath);
   if (!config) {
     throw new Error("flint.toml not found");
   }
+  if (!config.exports) {
+    config.exports = { required: [] };
+  }
+  if (!config.exports.required) {
+    config.exports.required = [];
+  }
+  const existing = config.exports.required.find(
+    (e) => e.name.toLowerCase() === declaration.name.toLowerCase()
+  );
+  if (existing) {
+    throw new Error(`Export "${declaration.name}" already declared`);
+  }
+  config.exports.required.push({
+    name: declaration.name,
+    file: declaration.file,
+    mode: declaration.mode,
+    ...declaration.depth !== void 0 ? { depth: declaration.depth } : {}
+  });
+  await writeFlintToml(flintPath, config);
+}
+async function removeExportFromConfig(flintPath, exportName) {
+  let config = await readFlintToml(flintPath);
+  if (!config?.exports?.required) return false;
+  const index = config.exports.required.findIndex(
+    (e) => e.name.toLowerCase() === exportName.toLowerCase()
+  );
+  if (index === -1) return false;
+  config.exports.required.splice(index, 1);
+  await writeFlintToml(flintPath, config);
+  return true;
+}
+async function getExportDeclarations(flintPath) {
+  const config = await readFlintToml(flintPath);
+  return config?.exports?.required || [];
+}
+function resolveFlintImports(config) {
+  return config.imports?.flints || config.imports?.required || [];
+}
+function ensureFlintImports(config) {
   if (!config.imports) {
-    config.imports = { required: [] };
+    config.imports = { flints: [] };
   }
-  if (!config.imports.required) {
-    config.imports.required = [];
+  if (config.imports.required && !config.imports.flints) {
+    config.imports.flints = config.imports.required;
   }
-  if (!config.imports.required.includes(ref)) {
-    config.imports.required.push(ref);
+  delete config.imports.required;
+  if (!config.imports.flints) {
+    config.imports.flints = [];
+  }
+  return config.imports.flints;
+}
+async function addImportToConfig(flintPath, ref) {
+  let config = await readFlintToml(flintPath);
+  if (!config) {
+    throw new Error("flint.toml not found");
+  }
+  const flints = ensureFlintImports(config);
+  if (!flints.includes(ref)) {
+    flints.push(ref);
     await writeFlintToml(flintPath, config);
   }
 }
 async function removeImportFromConfig(flintPath, ref) {
   let config = await readFlintToml(flintPath);
-  if (!config?.imports?.required) return false;
-  const index = config.imports.required.indexOf(ref);
+  if (!config) return false;
+  const flints = ensureFlintImports(config);
+  const index = flints.indexOf(ref);
   if (index === -1) {
     const lowerRef = ref.toLowerCase();
-    const foundIndex = config.imports.required.findIndex((r) => r.toLowerCase() === lowerRef);
+    const foundIndex = flints.findIndex((r) => r.toLowerCase() === lowerRef);
     if (foundIndex === -1) return false;
-    config.imports.required.splice(foundIndex, 1);
+    flints.splice(foundIndex, 1);
   } else {
-    config.imports.required.splice(index, 1);
+    flints.splice(index, 1);
   }
   await writeFlintToml(flintPath, config);
   return true;
 }
-async function getRequiredImports(flintPath) {
+async function getFlintImports(flintPath) {
   const config = await readFlintToml(flintPath);
-  return config?.imports?.required || [];
-}
-async function addWorkspaceEntry(flintPath, name, path) {
-  console.warn("addWorkspaceEntry is deprecated, use addWorkspaceReference instead");
-}
-async function removeWorkspaceEntry(flintPath, name) {
-  console.warn("removeWorkspaceEntry is deprecated, use removeWorkspaceReference instead");
-}
-async function getWorkspaceEntries(flintPath) {
-  return {};
-}
-async function getWorkspaceEntry(flintPath, name) {
-  return null;
+  if (!config) return [];
+  return resolveFlintImports(config);
 }
 
 export {
   parse,
+  stringify,
+  resolveShardMode,
+  isLocalShard,
   FLINT_CONFIG_FILENAME,
   FLINT_JSON_FILENAME,
   FLINT_VERSION,
@@ -1475,13 +1551,12 @@ export {
   removeLatticeReference,
   getLatticeReferences,
   getLatticeReference,
+  addExportToConfig,
+  removeExportFromConfig,
+  getExportDeclarations,
   addImportToConfig,
   removeImportFromConfig,
-  getRequiredImports,
-  addWorkspaceEntry,
-  removeWorkspaceEntry,
-  getWorkspaceEntries,
-  getWorkspaceEntry
+  getFlintImports
 };
 /*! Bundled license information:
 

package/dist/chunk-V7YA5RXL.js

@@ -0,0 +1,43 @@
+// ../../packages/flint/dist/chunk-STM4NXTT.js
+import { access } from "fs/promises";
+async function exists(path) {
+  try {
+    await access(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function runConcurrent(tasks, options = {}) {
+  const { concurrency = 10, onComplete, onError, onStart } = options;
+  const results = [];
+  if (tasks.length === 0) return results;
+  let taskIdx = 0;
+  async function runNext() {
+    while (taskIdx < tasks.length) {
+      const idx = taskIdx++;
+      const task = tasks[idx];
+      onStart?.(task.name);
+      try {
+        const value = await task.run();
+        results.push({ name: task.name, status: "ok", value });
+        onComplete?.(task.name, value);
+      } catch (err) {
+        const error = err instanceof Error ? err : new Error(String(err));
+        results.push({ name: task.name, status: "error", error });
+        onError?.(task.name, error);
+      }
+    }
+  }
+  const workers = [];
+  for (let i = 0; i < Math.min(concurrency, tasks.length); i++) {
+    workers.push(runNext());
+  }
+  await Promise.all(workers);
+  return results;
+}
+
+export {
+  exists,
+  runConcurrent
+};

package/dist/{chunk-F5Q2BJFK.js → chunk-VEO4E5HX.js}

@@ -1,10 +1,10 @@
-// ../../packages/flint/src/registry.ts
+// ../../packages/flint/dist/chunk-7YSFBSPS.js
 import { mkdir, readFile, writeFile } from "fs/promises";
 import { homedir } from "os";
 import { join, resolve } from "path";
 var REGISTRY_VERSION = 1;
 function getGlobalFlintDir() {
-  return join(homedir(), ".flint");
+  return join(homedir(), ".nuucognition", "flint");
 }
 function getFlintRegistryPath() {
   return join(getGlobalFlintDir(), "registry.json");
@@ -58,13 +58,14 @@ async function findFlintByPath(path) {
   const flints = await getFlintRegistry();
   return flints.find((f) => f.path === resolvedPath) ?? null;
 }
-async function findFlintById(_id) {
-  return null;
-}
 async function findFlintByName(name) {
   const flints = await getFlintRegistry();
   return flints.find((f) => f.name === name) ?? null;
 }
+async function isFlintNameTaken(name) {
+  const flints = await getFlintRegistry();
+  return flints.find((f) => f.name === name);
+}
 async function upsertFlintEntry(entry) {
   const normalizedEntry = { ...entry, path: resolve(entry.path) };
   const flints = await getFlintRegistry();
@@ -184,7 +185,7 @@ async function cleanRegistryFile() {
   return result;
 }
 async function registerFlintByPath(path, options) {
-  const { readFlintToml, hasFlintToml } = await import("./mesh-config-O3UKKKAO.js");
+  const { readFlintToml, hasFlintToml } = await import("./mesh-config-J6WB4RFV-G7RGPOZA.js");
   const isFlint = await hasFlintToml(path);
   if (!isFlint) {
     throw new Error(`Not a valid flint: ${path}
@@ -223,8 +224,8 @@ export {
   registerFlint,
   unregisterFlint,
   findFlintByPath,
-  findFlintById,
   findFlintByName,
+  isFlintNameTaken,
   upsertFlintEntry,
   updateFlintEntry,
   isPathRegistered,

package/dist/{exports-Y3NVZFFT.js → exports-KXKBTYJ2-A3QWNDEB.js}

@@ -3,12 +3,14 @@ import {
   buildExport,
   buildExportByName,
   cleanupStaleExports,
+  scanExportEligible,
   scanExports
-} from "./chunk-BVYUS7NX.js";
+} from "./chunk-K5QP4OME.js";
 export {
   buildAllExports,
   buildExport,
   buildExportByName,
   cleanupStaleExports,
+  scanExportEligible,
   scanExports
 };