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

package/bin/flint-prod.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 
-import { fileURLToPath } from 'node:url';
+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-EICASOEX.js → chunk-5YLBX2W6.js}

@@ -1,4 +1,4 @@
-// ../../packages/flint/src/mesh-config.ts
+// ../../packages/flint/dist/chunk-OXC4WBGK.js
 import { readFile, writeFile, stat } from "fs/promises";
 import { join } from "path";
 
@@ -828,8 +828,17 @@ function stringify(obj, { maxDepth = 1e3, numbersAsFloat = false } = {}) {
   return str;
 }
 
-// ../../packages/flint/src/mesh-config.ts
+// ../../packages/flint/dist/chunk-OXC4WBGK.js
 import { randomUUID } from "crypto";
+function resolveShardMode(decl) {
+  if (decl.mode) return decl.mode;
+  if (decl.dev) return "dev";
+  return void 0;
+}
+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 +973,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 +1025,65 @@ 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.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", "lattices"]);
   const unknownKeys = Object.keys(config).filter((k) => !knownKeys.has(k));
   if (unknownKeys.length > 0) {
     const unknownConfig = {};
@@ -1089,7 +1118,8 @@ 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;
+    const effectiveMode = options.mode || (options.dev ? "dev" : void 0);
+    if (effectiveMode) decl.mode = effectiveMode;
     config.shards[kebabName] = decl;
     await writeFlintToml(flintPath, config);
   }
@@ -1378,41 +1408,95 @@ 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.flints) {
+    config.imports.flints = config.imports.required;
+  }
+  delete config.imports.required;
+  if (!config.imports.flints) {
+    config.imports.flints = [];
   }
-  if (!config.imports.required) {
-    config.imports.required = [];
+  return config.imports.flints;
+}
+async function addImportToConfig(flintPath, ref) {
+  let config = await readFlintToml(flintPath);
+  if (!config) {
+    throw new Error("flint.toml not found");
   }
-  if (!config.imports.required.includes(ref)) {
-    config.imports.required.push(ref);
+  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 || [];
+  if (!config) return [];
+  return resolveFlintImports(config);
 }
+var getRequiredImports = getFlintImports;
 async function addWorkspaceEntry(flintPath, name, path) {
   console.warn("addWorkspaceEntry is deprecated, use addWorkspaceReference instead");
 }
@@ -1428,6 +1512,9 @@ async function getWorkspaceEntry(flintPath, name) {
 
 export {
   parse,
+  stringify,
+  resolveShardMode,
+  isLocalShard,
   FLINT_CONFIG_FILENAME,
   FLINT_JSON_FILENAME,
   FLINT_VERSION,
@@ -1475,8 +1562,12 @@ export {
   removeLatticeReference,
   getLatticeReferences,
   getLatticeReference,
+  addExportToConfig,
+  removeExportFromConfig,
+  getExportDeclarations,
   addImportToConfig,
   removeImportFromConfig,
+  getFlintImports,
   getRequiredImports,
   addWorkspaceEntry,
   removeWorkspaceEntry,

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

@@ -1,10 +1,10 @@
-// ../../packages/flint/src/registry.ts
+// ../../packages/flint/dist/chunk-CJE24DAP.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");
@@ -184,7 +184,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-VGFSHC2G-YCC4ZIAT.js");
   const isFlint = await hasFlintToml(path);
   if (!isFlint) {
     throw new Error(`Not a valid flint: ${path}

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

@@ -1,4 +1,4 @@
-// ../../packages/flint/src/exports.ts
+// ../../packages/flint/dist/chunk-E7CDAGZD.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-VGFSHC2G-YCC4ZIAT.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-VGFSHC2G-YCC4ZIAT.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 });
   }
@@ -345,11 +410,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 +445,7 @@ async function buildAllExports(flintPath) {
 
 export {
   scanExports,
+  scanExportEligible,
   buildExport,
   buildExportByName,
   cleanupStaleExports,

package/dist/{exports-Y3NVZFFT.js → exports-CA5QHVI7-6IDFKMCF.js}

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