@nuucognition/flint-cli 0.2.0-beta.2 → 0.3.0-alpha.1

package/dist/chunk-KVE7WLA2.js

@@ -0,0 +1,297 @@
+import {
+  readFlintToml,
+  toKebabCase
+} from "./chunk-KLFK7CPM.js";
+
+// ../../packages/flint/dist/chunk-7OFS4TXV.js
+import { join, dirname, basename } from "path";
+import { readFile, writeFile, mkdir, readdir, rm, stat as stat2 } from "fs/promises";
+import { join as join2 } from "path";
+import { randomUUID } from "crypto";
+var FLINT_DIR = ".flint";
+function getFlintConfigDir(flintPath) {
+  return join(flintPath, FLINT_DIR);
+}
+function getTypePrefix(_type) {
+  return "(Flint)";
+}
+function getMetadataDir(flintPath) {
+  return join2(flintPath, "Mesh", "Metadata");
+}
+function getReferencesMetadataDir(flintPath) {
+  return join2(getMetadataDir(flintPath), "Codebase References");
+}
+function getConnectionsMetadataDir(flintPath) {
+  return join2(getMetadataDir(flintPath), "Flint Connections");
+}
+function getSourcesMetadataDir(flintPath) {
+  return join2(getMetadataDir(flintPath), "Sources");
+}
+function getReferenceMetadataPath(flintPath, name) {
+  const slug = toKebabCase(name);
+  return join2(getReferencesMetadataDir(flintPath), `rf-${slug}.md`);
+}
+function getConnectionMetadataPath(flintPath, name) {
+  const slug = toKebabCase(name);
+  return join2(getConnectionsMetadataDir(flintPath), `con-${slug}.md`);
+}
+function getSourceMetadataPath(flintPath, importRef) {
+  const slug = toKebabCase(importRef.replace("/", "-"));
+  return join2(getSourcesMetadataDir(flintPath), `src-${slug}.md`);
+}
+async function fileExists(path) {
+  try {
+    await stat2(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 buildReferenceContent(ref, id, notes) {
+  return `---
+id: ${id}
+tags:
+  - "#f/metadata"
+  - "#f/reference"
+type: ${ref.type}
+---
+
+Execute \`flint resolve codebase ${ref.name}\` to get the local path.
+
+${notes}
+`;
+}
+function buildConnectionContent(declaration, id, notes) {
+  return `---
+id: ${id}
+tags:
+  - "#f/metadata"
+  - "#f/connection"
+type: flint
+---
+
+Execute \`flint resolve connection ${declaration.name}\` to get the local path.
+
+${notes}
+`;
+}
+function buildSourceContent(importRef, id, notes) {
+  return `---
+id: ${id}
+tags:
+  - "#f/metadata"
+  - "#f/source"
+type: flint-export
+---
+
+Execute \`flint resolve source "${importRef}"\` to get the local path.
+
+${notes}
+`;
+}
+async function generateReferenceMetadata(flintPath, ref) {
+  const filePath = getReferenceMetadataPath(flintPath, ref.name);
+  await mkdir(getReferencesMetadataDir(flintPath), { recursive: true });
+  const result = await syncMetadataFile(
+    filePath,
+    (id, notes) => buildReferenceContent(ref, id, notes)
+  );
+  return result === "created";
+}
+async function generateConnectionMetadata(flintPath, declaration) {
+  const filePath = getConnectionMetadataPath(flintPath, declaration.name);
+  await mkdir(getConnectionsMetadataDir(flintPath), { recursive: true });
+  const result = await syncMetadataFile(
+    filePath,
+    (id, notes) => buildConnectionContent(declaration, id, notes)
+  );
+  return result === "created";
+}
+async function generateSourceMetadata(flintPath, importRef) {
+  const filePath = getSourceMetadataPath(flintPath, importRef);
+  await mkdir(getSourcesMetadataDir(flintPath), { recursive: true });
+  const result = await syncMetadataFile(
+    filePath,
+    (id, notes) => buildSourceContent(importRef, id, notes)
+  );
+  return result === "created";
+}
+async function resolveCodebase(flintPath, name) {
+  const { readReferencesState } = await import("./workspace-local-LKB4MTN2-OY5UVN3K.js");
+  const state = await readReferencesState(flintPath);
+  const normalizedName = name.toLowerCase();
+  const fulfillment = state.references.find(
+    (r) => r.name.toLowerCase() === normalizedName
+  );
+  if (fulfillment?.path) {
+    return { status: "fulfilled", name, type: "codebase", path: fulfillment.path };
+  }
+  return { status: "unfulfilled", name, type: "codebase" };
+}
+async function resolveConnection(flintPath, name) {
+  const { readConnectionsState } = await import("./connections-AXGFYQOK-A6BXCAC7.js");
+  const state = await readConnectionsState(flintPath);
+  const normalizedName = name.toLowerCase();
+  const fulfillment = state.connections.find(
+    (c) => c.name.toLowerCase() === normalizedName
+  );
+  if (fulfillment?.path) {
+    return { status: "fulfilled", name, type: "connection", path: fulfillment.path };
+  }
+  return { status: "unfulfilled", name, type: "connection" };
+}
+async function resolveSource(flintPath, importRef) {
+  const parts = importRef.split("/");
+  const flintName = parts[0] || importRef;
+  const exportName = parts[1] || "";
+  const sourcePath = join2(flintPath, "Sources", "Flints", `(Flint) ${flintName}`, `(Mesh) ${exportName}`);
+  try {
+    await stat2(sourcePath);
+    return { status: "fulfilled", name: importRef, type: "source", path: sourcePath };
+  } catch {
+    return { status: "unfulfilled", name: importRef, type: "source", path: sourcePath };
+  }
+}
+async function listMetadataFiles(dirPath, prefix) {
+  try {
+    const entries = await readdir(dirPath);
+    return entries.filter((e) => e.startsWith(prefix) && e.endsWith(".md"));
+  } catch {
+    return [];
+  }
+}
+async function syncMetadata(flintPath) {
+  const result = { created: [], removed: [], unchanged: [] };
+  const config = await readFlintToml(flintPath);
+  if (!config) return result;
+  const references = config.workspace?.references || [];
+  const expectedRefFiles = new Set(
+    references.map((r) => `rf-${toKebabCase(r.name)}.md`)
+  );
+  for (const ref of references) {
+    const created = await generateReferenceMetadata(flintPath, ref);
+    const fileName = `rf-${toKebabCase(ref.name)}.md`;
+    if (created) {
+      result.created.push(fileName);
+    } else {
+      result.unchanged.push(fileName);
+    }
+  }
+  const existingRefFiles = await listMetadataFiles(
+    getReferencesMetadataDir(flintPath),
+    "rf-"
+  );
+  for (const file of existingRefFiles) {
+    if (!expectedRefFiles.has(file)) {
+      try {
+        await rm(join2(getReferencesMetadataDir(flintPath), file));
+        result.removed.push(file);
+      } catch {
+      }
+    }
+  }
+  const connections = config.connections?.flints || [];
+  const expectedConFiles = new Set(
+    connections.map((c) => `con-${toKebabCase(c.name)}.md`)
+  );
+  for (const con of connections) {
+    const created = await generateConnectionMetadata(flintPath, con);
+    const fileName = `con-${toKebabCase(con.name)}.md`;
+    if (created) {
+      result.created.push(fileName);
+    } else {
+      result.unchanged.push(fileName);
+    }
+  }
+  const existingConFiles = await listMetadataFiles(
+    getConnectionsMetadataDir(flintPath),
+    "con-"
+  );
+  for (const file of existingConFiles) {
+    if (!expectedConFiles.has(file)) {
+      try {
+        await rm(join2(getConnectionsMetadataDir(flintPath), file));
+        result.removed.push(file);
+      } catch {
+      }
+    }
+  }
+  const imports = config.imports?.flints || config.imports?.required || [];
+  const expectedSrcFiles = new Set(
+    imports.map((ref) => `src-${toKebabCase(ref.replace("/", "-"))}.md`)
+  );
+  for (const importRef of imports) {
+    const created = await generateSourceMetadata(flintPath, importRef);
+    const fileName = `src-${toKebabCase(importRef.replace("/", "-"))}.md`;
+    if (created) {
+      result.created.push(fileName);
+    } else {
+      result.unchanged.push(fileName);
+    }
+  }
+  const existingSrcFiles = await listMetadataFiles(
+    getSourcesMetadataDir(flintPath),
+    "src-"
+  );
+  for (const file of existingSrcFiles) {
+    if (!expectedSrcFiles.has(file)) {
+      try {
+        await rm(join2(getSourcesMetadataDir(flintPath), file));
+        result.removed.push(file);
+      } catch {
+      }
+    }
+  }
+  return result;
+}
+async function ensureMetadataDirs(flintPath) {
+  await mkdir(getReferencesMetadataDir(flintPath), { recursive: true });
+  await mkdir(getConnectionsMetadataDir(flintPath), { recursive: true });
+  await mkdir(getSourcesMetadataDir(flintPath), { recursive: true });
+}
+
+export {
+  getFlintConfigDir,
+  getTypePrefix,
+  getReferencesMetadataDir,
+  getConnectionsMetadataDir,
+  getReferenceMetadataPath,
+  getConnectionMetadataPath,
+  generateReferenceMetadata,
+  generateConnectionMetadata,
+  resolveCodebase,
+  resolveConnection,
+  resolveSource,
+  syncMetadata,
+  ensureMetadataDirs
+};

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

@@ -1,4 +1,4 @@
-// ../../packages/flint/dist/chunk-CKCIJQXP.js
+// ../../packages/flint/dist/chunk-HCE4DXJK.js
 import { readdir, readFile, mkdir, writeFile, rm, stat } from "fs/promises";
 import { join, basename, dirname, resolve, relative, sep } from "path";
 async function exists(path) {
@@ -158,22 +158,6 @@ async function findFilesRecursively(dir, fileName, matches = []) {
   }
   return matches;
 }
-async function findExportFiles(dir, files = []) {
-  try {
-    const entries = await readdir(dir, { withFileTypes: true });
-    for (const entry of entries) {
-      const fullPath = join(dir, entry.name);
-      if (entry.isFile() && entry.name.startsWith("(Export) ") && entry.name.endsWith(".md")) {
-        files.push(fullPath);
-      }
-      if (entry.isDirectory()) {
-        await findExportFiles(fullPath, files);
-      }
-    }
-  } catch {
-  }
-  return files;
-}
 async function resolveDocument(docRef, flintPath) {
   const trimmedRef = docRef.trim();
   if (!trimmedRef) {
@@ -224,13 +208,13 @@ function getDisambiguatedExportName(flintPath, sourcePath, baseName) {
   return `${baseName} (${dirLabel})`;
 }
 async function scanExports(flintPath) {
-  const { readFlintToml } = await import("./mesh-config-J6WB4RFV-G7RGPOZA.js");
+  const { readFlintToml } = await import("./mesh-config-7GOTOVCM-TZEJ43E5.js");
   const config = await readFlintToml(flintPath);
   const declarations = config?.exports?.required;
-  if (declarations && declarations.length > 0) {
-    return scanExportsFromConfig(flintPath, declarations);
+  if (!declarations || declarations.length === 0) {
+    return [];
   }
-  return scanExportsLegacy(flintPath);
+  return scanExportsFromConfig(flintPath, declarations);
 }
 async function scanExportsFromConfig(flintPath, declarations) {
   const manifests = [];
@@ -248,29 +232,10 @@ async function scanExportsFromConfig(flintPath, declarations) {
   }
   return manifests;
 }
-async function scanExportsLegacy(flintPath) {
-  const meshDir = join(flintPath, "Mesh");
-  if (!await exists(meshDir)) {
-    return [];
-  }
-  const exportFiles = await findExportFiles(meshDir);
-  const manifests = [];
-  for (const filePath of exportFiles) {
-    try {
-      const content = await readFile(filePath, "utf-8");
-      const fileName = basename(filePath, ".md");
-      const name = fileName.replace(/^\(Export\)\s*/, "");
-      const manifest = parseExportDocument(content, name, filePath);
-      manifests.push(manifest);
-    } catch {
-    }
-  }
-  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 { readFlintToml } = await import("./mesh-config-7GOTOVCM-TZEJ43E5.js");
   const config = await readFlintToml(flintPath);
   const declared = new Set(
     (config?.exports?.required || []).map((d) => d.file.replace(/\.md$/, "").toLowerCase())

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

@@ -1,4 +1,4 @@
-// ../../packages/flint/dist/chunk-7YSFBSPS.js
+// ../../packages/flint/dist/chunk-X3YVJP3U.js
 import { mkdir, readFile, writeFile } from "fs/promises";
 import { homedir } from "os";
 import { join, resolve } from "path";
@@ -159,9 +159,6 @@ async function cleanRegistryFile() {
       name: entry.name,
       path: entry.path
     };
-    if (entry.type === "flint" || entry.type === "subflint") {
-      cleanEntry.type = entry.type;
-    }
     if (entry.source === "local") {
       cleanEntry.source = entry.source;
     }
@@ -185,7 +182,7 @@ async function cleanRegistryFile() {
   return result;
 }
 async function registerFlintByPath(path, options) {
-  const { readFlintToml, hasFlintToml } = await import("./mesh-config-J6WB4RFV-G7RGPOZA.js");
+  const { readFlintToml, hasFlintToml } = await import("./mesh-config-7GOTOVCM-TZEJ43E5.js");
   const isFlint = await hasFlintToml(path);
   if (!isFlint) {
     throw new Error(`Not a valid flint: ${path}
@@ -196,7 +193,6 @@ Missing flint.toml`);
     throw new Error(`Invalid flint.toml at ${path}: missing flint.name`);
   }
   const name = toml.flint.name;
-  const type = toml.flint.type ?? "flint";
   const existing = await findFlintByPath(path);
   if (existing && !options?.force) {
     throw new Error(`Already registered: "${existing.name}" at ${path}`);
@@ -204,7 +200,6 @@ Missing flint.toml`);
   const entry = {
     name,
     path,
-    type,
     source: "local"
   };
   if (toml.flint.tags && toml.flint.tags.length > 0) {