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

package/dist/{chunk-5YLBX2W6.js → chunk-KLFK7CPM.js}

@@ -1,6 +1,6 @@
-// ../../packages/flint/dist/chunk-OXC4WBGK.js
-import { readFile, writeFile, stat } from "fs/promises";
-import { join } from "path";
+// ../../packages/flint/dist/chunk-HP5CLO2G.js
+import { readFile, writeFile, stat, mkdir } from "fs/promises";
+import { join as pathJoin } from "path";
 
 // ../../node_modules/.pnpm/smol-toml@1.6.0/node_modules/smol-toml/dist/error.js
 function getLineColFromPtr(string, ptr) {
@@ -828,12 +828,11 @@ function stringify(obj, { maxDepth = 1e3, numbersAsFloat = false } = {}) {
   return str;
 }
 
-// ../../packages/flint/dist/chunk-OXC4WBGK.js
+// ../../packages/flint/dist/chunk-HP5CLO2G.js
 import { randomUUID } from "crypto";
+var join = pathJoin;
 function resolveShardMode(decl) {
-  if (decl.mode) return decl.mode;
-  if (decl.dev) return "dev";
-  return void 0;
+  return decl.mode;
 }
 function isLocalShard(decl) {
   const mode = resolveShardMode(decl);
@@ -841,7 +840,7 @@ function isLocalShard(decl) {
 }
 var FLINT_CONFIG_FILENAME = "flint.toml";
 var FLINT_JSON_FILENAME = "flint.json";
-var FLINT_VERSION = "0.2.0";
+var FLINT_VERSION = "0.3.0";
 function toKebabCase(name) {
   return name.replace(/\([^)]*\)\s*/g, "").toLowerCase().replace(/\s+/g, "-").replace(/[^a-z0-9-]/g, "").replace(/^-+|-+$/g, "");
 }
@@ -871,29 +870,17 @@ var DEFAULT_SHARD_SOURCES = {
   orbcode: "NUU-Cognition/shard-orbcode",
   projects: "NUU-Cognition/shard-projects"
 };
-var DEFAULT_MOD_SOURCES = {
-  "claude-code": "NUU-Cognition/flint-mod-claude-code",
-  agents: "NUU-Cognition/flint-mod-agents"
-};
-function createFlintToml(name, shards = [], mods = [], type = "flint") {
+function createFlintToml(name, shards = []) {
   const shardDeclarations = {};
   for (const shard of shards) {
     shardDeclarations[shard] = { source: DEFAULT_SHARD_SOURCES[shard] || shard };
   }
   const config = {
     flint: {
-      name,
-      type
+      name
     },
     shards: shardDeclarations
   };
-  if (mods.length > 0) {
-    const modDeclarations = {};
-    for (const mod of mods) {
-      modDeclarations[mod] = { source: DEFAULT_MOD_SOURCES[mod] || mod };
-    }
-    config.mods = modDeclarations;
-  }
   return config;
 }
 function createFlintJson() {
@@ -1020,18 +1007,6 @@ function formatFlintToml(config) {
       lines.push("");
     }
   }
-  if (config.mods) {
-    const modDeclarations = getModDeclarationsFromConfig(config);
-    if (Object.keys(modDeclarations).length > 0) {
-      lines.push("[mods]");
-      for (const [name, decl] of Object.entries(modDeclarations)) {
-        const fields = { source: decl.source };
-        if (decl.dev) fields.dev = true;
-        lines.push(`${name} = ${inlineTable(fields)}`);
-      }
-      lines.push("");
-    }
-  }
   if (config.exports?.required?.length) {
     lines.push("[exports]");
     const items = config.exports.required.map((e) => {
@@ -1075,15 +1050,18 @@ function formatFlintToml(config) {
     lines.push(`flints = ${inlineTableArray(items).join("\n")}`);
     lines.push("");
   }
-  if (config.lattices?.length) {
-    for (const lattice of config.lattices) {
-      lines.push("[[lattices]]");
-      lines.push(`name = ${tv(lattice.name)}`);
-      lines.push(`path = ${tv(lattice.path)}`);
-      lines.push("");
-    }
+  if (config.git?.remote) {
+    lines.push("[git]");
+    lines.push(`remote = ${tv(config.git.remote)}`);
+    lines.push("");
   }
-  const knownKeys = /* @__PURE__ */ new Set(["flint", "shards", "mods", "exports", "imports", "workspace", "connections", "lattices"]);
+  if (config.lattices?.references?.length) {
+    lines.push("[lattices]");
+    const items = config.lattices.references.map((l) => ({ name: l.name }));
+    lines.push(`references = ${inlineTableArray(items).join("\n")}`);
+    lines.push("");
+  }
+  const knownKeys = /* @__PURE__ */ new Set(["flint", "shards", "exports", "imports", "workspace", "connections", "git", "lattices"]);
   const unknownKeys = Object.keys(config).filter((k) => !knownKeys.has(k));
   if (unknownKeys.length > 0) {
     const unknownConfig = {};
@@ -1118,8 +1096,7 @@ async function addShardToConfig(flintPath, shardName, source, options = {}) {
   const effectiveSource = source || kebabName;
   if (!existing || existing.source !== effectiveSource) {
     const decl = { source: effectiveSource };
-    const effectiveMode = options.mode || (options.dev ? "dev" : void 0);
-    if (effectiveMode) decl.mode = effectiveMode;
+    if (options.mode) decl.mode = options.mode;
     config.shards[kebabName] = decl;
     await writeFlintToml(flintPath, config);
   }
@@ -1136,70 +1113,6 @@ async function removeShardFromConfig(flintPath, shardName) {
   }
   await writeFlintToml(flintPath, config);
 }
-async function addModToConfig(flintPath, modName, source = "builtin", options = {}) {
-  let config = await readFlintToml(flintPath);
-  if (!config) {
-    throw new Error("flint.toml not found");
-  }
-  const kebabName = toKebabCase(modName);
-  if (!config.mods) {
-    config.mods = {};
-  }
-  const declaration = { source };
-  if (options.dev) declaration.dev = true;
-  config.mods[kebabName] = declaration;
-  await writeFlintToml(flintPath, config);
-}
-async function removeModFromConfig(flintPath, modName) {
-  let config = await readFlintToml(flintPath);
-  if (!config?.mods) return;
-  const kebabName = toKebabCase(modName);
-  delete config.mods[kebabName];
-  if (config.mods.required) {
-    config.mods.required = config.mods.required.filter((n) => n !== kebabName);
-  }
-  await writeFlintToml(flintPath, config);
-}
-function getModDeclarationsFromConfig(config) {
-  if (!config.mods) return {};
-  const declarations = {};
-  for (const [key, value] of Object.entries(config.mods)) {
-    if (key === "required") continue;
-    if (value && typeof value === "object" && !Array.isArray(value) && "source" in value) {
-      declarations[key] = value;
-    }
-  }
-  if (config.mods.required && Array.isArray(config.mods.required)) {
-    for (const name of config.mods.required) {
-      if (!declarations[name]) {
-        declarations[name] = { source: "builtin" };
-      }
-    }
-  }
-  return declarations;
-}
-async function getModDeclarations(flintPath) {
-  const config = await readFlintToml(flintPath);
-  if (!config) return {};
-  return getModDeclarationsFromConfig(config);
-}
-async function migrateModConfig(flintPath) {
-  const config = await readFlintToml(flintPath);
-  if (!config?.mods?.required || !Array.isArray(config.mods.required)) {
-    return false;
-  }
-  if (config.mods.required.length === 0) {
-    return false;
-  }
-  for (const name of config.mods.required) {
-    if (!config.mods[name]) {
-      config.mods[name] = { source: "builtin" };
-    }
-  }
-  delete config.mods.required;
-  await writeFlintToml(flintPath, config);
-  return true;
-}
 async function getRequiredShardNames(flintPath) {
   const config = await readFlintToml(flintPath);
   if (!config?.shards) return [];
@@ -1374,40 +1287,101 @@ async function getWorkspaceSourceRepository(flintPath, name) {
   const normalizedName = name.toLowerCase();
   return config?.workspace?.sources?.repositories?.find((r) => r.name.toLowerCase() === normalizedName) || null;
 }
-async function addLatticeReference(flintPath, name, path) {
+function getLatticesStatePath(flintPath) {
+  return pathJoin(flintPath, ".flint", "lattices.json");
+}
+async function readLatticesState(flintPath) {
+  const statePath = getLatticesStatePath(flintPath);
+  try {
+    const content = await readFile(statePath, "utf-8");
+    return JSON.parse(content);
+  } catch {
+    return { version: 1, lattices: [] };
+  }
+}
+async function writeLatticesState(flintPath, state) {
+  const statePath = getLatticesStatePath(flintPath);
+  const dir = pathJoin(flintPath, ".flint");
+  await mkdir(dir, { recursive: true });
+  await writeFile(statePath, JSON.stringify(state, null, 2) + "\n");
+}
+async function addLatticeDeclaration(flintPath, name) {
   let config = await readFlintToml(flintPath);
   if (!config) {
     throw new Error("flint.toml not found");
   }
   if (!config.lattices) {
-    config.lattices = [];
+    config.lattices = { references: [] };
   }
-  const existing = config.lattices.find((entry) => entry.name.toLowerCase() === name.toLowerCase());
+  if (!config.lattices.references) {
+    config.lattices.references = [];
+  }
+  const existing = config.lattices.references.find(
+    (entry) => entry.name.toLowerCase() === name.toLowerCase()
+  );
   if (existing) {
-    throw new Error(`Lattice "${name}" already exists`);
+    throw new Error(`Lattice "${name}" is already declared`);
   }
-  config.lattices.push({ name, path });
+  config.lattices.references.push({ name });
   await writeFlintToml(flintPath, config);
 }
-async function removeLatticeReference(flintPath, name) {
+async function removeLatticeDeclaration(flintPath, name) {
   let config = await readFlintToml(flintPath);
-  if (!config?.lattices) return false;
+  if (!config?.lattices?.references) return false;
   const normalizedName = name.toLowerCase();
-  const index = config.lattices.findIndex((entry) => entry.name.toLowerCase() === normalizedName);
+  const index = config.lattices.references.findIndex(
+    (entry) => entry.name.toLowerCase() === normalizedName
+  );
   if (index === -1) return false;
-  config.lattices.splice(index, 1);
+  config.lattices.references.splice(index, 1);
   await writeFlintToml(flintPath, config);
+  const state = await readLatticesState(flintPath);
+  state.lattices = state.lattices.filter(
+    (l) => l.name.toLowerCase() !== normalizedName
+  );
+  await writeLatticesState(flintPath, state);
   return true;
 }
-async function getLatticeReferences(flintPath) {
+async function fulfillLattice(flintPath, name, latticePath, lang) {
+  const fulfillment = {
+    name,
+    path: latticePath,
+    lang,
+    fulfilled: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  const state = await readLatticesState(flintPath);
+  const existingIndex = state.lattices.findIndex(
+    (l) => l.name.toLowerCase() === name.toLowerCase()
+  );
+  if (existingIndex >= 0) {
+    state.lattices[existingIndex] = fulfillment;
+  } else {
+    state.lattices.push(fulfillment);
+  }
+  await writeLatticesState(flintPath, state);
+  return fulfillment;
+}
+async function getLatticeDeclarations(flintPath) {
   const config = await readFlintToml(flintPath);
-  return config?.lattices || [];
+  return config?.lattices?.references || [];
 }
-async function getLatticeReference(flintPath, name) {
+async function getLatticeDeclaration(flintPath, name) {
   const config = await readFlintToml(flintPath);
   const normalizedName = name.toLowerCase();
-  return config?.lattices?.find((entry) => entry.name.toLowerCase() === normalizedName) || null;
-}
+  return config?.lattices?.references?.find(
+    (entry) => entry.name.toLowerCase() === normalizedName
+  ) || null;
+}
+async function getLatticeFulfillment(flintPath, name) {
+  const state = await readLatticesState(flintPath);
+  return state.lattices.find(
+    (l) => l.name.toLowerCase() === name.toLowerCase()
+  ) || null;
+}
+var addLatticeReference = async (flintPath, name, _path) => addLatticeDeclaration(flintPath, name);
+var removeLatticeReference = async (flintPath, name) => removeLatticeDeclaration(flintPath, name);
+var getLatticeReferences = async (flintPath) => getLatticeDeclarations(flintPath);
+var getLatticeReference = async (flintPath, name) => getLatticeDeclaration(flintPath, name);
 async function addExportToConfig(flintPath, declaration) {
   let config = await readFlintToml(flintPath);
   if (!config) {
@@ -1496,19 +1470,6 @@ async function getFlintImports(flintPath) {
   if (!config) return [];
   return resolveFlintImports(config);
 }
-var getRequiredImports = getFlintImports;
-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;
-}
 
 export {
   parse,
@@ -1535,11 +1496,6 @@ export {
   writeFlintToml,
   addShardToConfig,
   removeShardFromConfig,
-  addModToConfig,
-  removeModFromConfig,
-  getModDeclarationsFromConfig,
-  getModDeclarations,
-  migrateModConfig,
   getRequiredShardNames,
   getShardDeclarationsFromConfig,
   getShardDeclarations,
@@ -1558,6 +1514,13 @@ export {
   removeWorkspaceSourceRepository,
   getWorkspaceSourceRepositories,
   getWorkspaceSourceRepository,
+  readLatticesState,
+  addLatticeDeclaration,
+  removeLatticeDeclaration,
+  fulfillLattice,
+  getLatticeDeclarations,
+  getLatticeDeclaration,
+  getLatticeFulfillment,
   addLatticeReference,
   removeLatticeReference,
   getLatticeReferences,
@@ -1567,12 +1530,7 @@ export {
   getExportDeclarations,
   addImportToConfig,
   removeImportFromConfig,
-  getFlintImports,
-  getRequiredImports,
-  addWorkspaceEntry,
-  removeWorkspaceEntry,
-  getWorkspaceEntries,
-  getWorkspaceEntry
+  getFlintImports
 };
 /*! Bundled license information:
 

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
+};