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

package/README.md

@@ -64,7 +64,6 @@ flint list --full-path
 | `--json` | Output as JSON |
 | `--full-path` | Show full paths |
 | `-s, --status` | Show valid/broken status |
-| `--sub` | Include subflints (dev mode only) |
 
 **Aliases:** `flint ls`
 

package/dist/chunk-2Q7QG2UK.js

@@ -0,0 +1,374 @@
+import {
+  generateReferenceMetadata,
+  getFlintConfigDir,
+  getReferenceMetadataPath,
+  getReferencesMetadataDir
+} from "./chunk-KVE7WLA2.js";
+import {
+  getWorkspaceReferences,
+  getWorkspaceRepositories,
+  getWorkspaceSourceRepositories,
+  parse
+} from "./chunk-KLFK7CPM.js";
+
+// ../../packages/flint/dist/chunk-K24H5FBA.js
+import { readFile, writeFile, mkdir, stat, unlink, access } from "fs/promises";
+import { join } from "path";
+import { exec } from "child_process";
+import { promisify } from "util";
+import { rm } from "fs/promises";
+var execAsync = promisify(exec);
+var LEGACY_WORKSPACE_CONFIG_FILENAME = "workspace.toml";
+function getWorkspaceReferencesDir(flintPath) {
+  return getReferencesMetadataDir(flintPath);
+}
+function toKebabCase(name) {
+  return name.toLowerCase().replace(/\s+/g, "-");
+}
+function getWorkspaceReferenceFilePath(flintPath, name) {
+  return getReferenceMetadataPath(flintPath, name);
+}
+function getLegacyWorkspaceConfigPath(flintPath) {
+  return join(getFlintConfigDir(flintPath), LEGACY_WORKSPACE_CONFIG_FILENAME);
+}
+function getLegacyWorkspaceDir(flintPath) {
+  return join(flintPath, "Workspace");
+}
+function getReferencesStatePath(flintPath) {
+  return join(getFlintConfigDir(flintPath), "references.json");
+}
+async function readReferencesState(flintPath) {
+  try {
+    const content = await readFile(getReferencesStatePath(flintPath), "utf-8");
+    return JSON.parse(content);
+  } catch {
+    return { version: 1, references: [] };
+  }
+}
+async function writeReferencesState(flintPath, state) {
+  const statePath = getReferencesStatePath(flintPath);
+  await mkdir(getFlintConfigDir(flintPath), { recursive: true });
+  await writeFile(statePath, JSON.stringify(state, null, 2));
+}
+async function updateReferenceState(flintPath, name, type, path) {
+  const state = await readReferencesState(flintPath);
+  const fulfillment = {
+    name,
+    type,
+    path,
+    fulfilled: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  const existingIndex = state.references.findIndex(
+    (r) => r.name.toLowerCase() === name.toLowerCase()
+  );
+  if (existingIndex >= 0) {
+    state.references[existingIndex] = fulfillment;
+  } else {
+    state.references.push(fulfillment);
+  }
+  await writeReferencesState(flintPath, state);
+}
+async function removeReferenceState(flintPath, name) {
+  const state = await readReferencesState(flintPath);
+  const normalizedName = name.toLowerCase();
+  const index = state.references.findIndex(
+    (r) => r.name.toLowerCase() === normalizedName
+  );
+  if (index >= 0) {
+    state.references.splice(index, 1);
+    await writeReferencesState(flintPath, state);
+    return true;
+  }
+  return false;
+}
+async function pathExists(path) {
+  try {
+    await stat(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function readReferencePath(flintPath, name) {
+  const state = await readReferencesState(flintPath);
+  const normalizedName = name.toLowerCase();
+  const fulfillment = state.references.find(
+    (r) => r.name.toLowerCase() === normalizedName
+  );
+  return fulfillment?.path || null;
+}
+async function writeReferenceFile(flintPath, name, targetPath, type = "codebase") {
+  await generateReferenceMetadata(flintPath, { name, type });
+  await updateReferenceState(flintPath, name, type, targetPath);
+  return getWorkspaceReferenceFilePath(flintPath, name);
+}
+async function deleteReferenceFile(flintPath, name) {
+  const filePath = getWorkspaceReferenceFilePath(flintPath, name);
+  try {
+    await unlink(filePath);
+    return true;
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      return false;
+    }
+    throw error;
+  }
+}
+async function getWorkspaceStatus(flintPath) {
+  const declarations = await getWorkspaceReferences(flintPath);
+  const statuses = [];
+  for (const ref of declarations) {
+    const referencePath = await readReferencePath(flintPath, ref.name);
+    if (!referencePath) {
+      statuses.push({
+        name: ref.name,
+        type: ref.type,
+        status: "unfulfilled"
+      });
+    } else if (await pathExists(referencePath)) {
+      statuses.push({
+        name: ref.name,
+        type: ref.type,
+        status: "fulfilled",
+        path: referencePath
+      });
+    } else {
+      statuses.push({
+        name: ref.name,
+        type: ref.type,
+        status: "missing",
+        path: referencePath
+      });
+    }
+  }
+  return statuses;
+}
+async function getUnfulfilledWorkspaces(flintPath) {
+  const statuses = await getWorkspaceStatus(flintPath);
+  return statuses.filter((s) => s.status === "unfulfilled").map((s) => s.name);
+}
+async function setWorkspacePath(flintPath, name, path) {
+  const declarations = await getWorkspaceReferences(flintPath);
+  const ref = declarations.find((r) => r.name.toLowerCase() === name.toLowerCase());
+  const type = ref?.type || "codebase";
+  await writeReferenceFile(flintPath, name, path, type);
+}
+async function removeWorkspacePath(flintPath, name) {
+  await removeReferenceState(flintPath, name);
+  return deleteReferenceFile(flintPath, name);
+}
+async function getWorkspacePath(flintPath, name) {
+  return readReferencePath(flintPath, name);
+}
+function getWorkspaceRepositoriesDir(flintPath) {
+  return join(flintPath, "Workspace", "Repositories");
+}
+function getRepositoryPath(flintPath, name) {
+  const kebabName = toKebabCase(name);
+  return join(getWorkspaceRepositoriesDir(flintPath), kebabName);
+}
+async function createRepository(flintPath, name, url) {
+  const repositoriesDir = getWorkspaceRepositoriesDir(flintPath);
+  await mkdir(repositoriesDir, { recursive: true });
+  const repoPath = getRepositoryPath(flintPath, name);
+  if (await pathExists(repoPath)) {
+    throw new Error(`Repository folder already exists: ${repoPath}`);
+  }
+  await mkdir(repoPath, { recursive: true });
+  try {
+    await execAsync("git init", { cwd: repoPath });
+    await execAsync(`git remote add origin "${url}"`, { cwd: repoPath });
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    await rm(repoPath, { recursive: true, force: true });
+    throw new Error(`Failed to initialize repository: ${message}`);
+  }
+  return repoPath;
+}
+async function cloneRepository(flintPath, name, url) {
+  const repositoriesDir = getWorkspaceRepositoriesDir(flintPath);
+  await mkdir(repositoriesDir, { recursive: true });
+  const repoPath = getRepositoryPath(flintPath, name);
+  if (await pathExists(repoPath)) {
+    throw new Error(`Repository folder already exists: ${repoPath}`);
+  }
+  try {
+    await execAsync(`git clone "${url}" "${repoPath}"`);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw new Error(`Failed to clone repository: ${message}`);
+  }
+  return repoPath;
+}
+async function removeRepositoryFolder(flintPath, name) {
+  const repoPath = getRepositoryPath(flintPath, name);
+  if (!await pathExists(repoPath)) {
+    return false;
+  }
+  await rm(repoPath, { recursive: true, force: true });
+  return true;
+}
+async function updateRepository(flintPath, name, url) {
+  const repoPath = getRepositoryPath(flintPath, name);
+  if (await pathExists(repoPath)) {
+    await execAsync("git pull", { cwd: repoPath });
+    return repoPath;
+  }
+  return cloneRepository(flintPath, name, url);
+}
+async function freshCloneRepository(flintPath, name, url) {
+  await removeRepositoryFolder(flintPath, name);
+  return cloneRepository(flintPath, name, url);
+}
+async function getRepositoryStatus(flintPath) {
+  const declarations = await getWorkspaceRepositories(flintPath);
+  const statuses = [];
+  for (const repo of declarations) {
+    const repoPath = getRepositoryPath(flintPath, repo.name);
+    const exists = await pathExists(repoPath);
+    statuses.push({
+      name: repo.name,
+      url: repo.url,
+      status: exists ? "cloned" : "missing",
+      path: repoPath
+    });
+  }
+  return statuses;
+}
+function getWorkspaceSourceRepositoriesDir(flintPath) {
+  return join(flintPath, "Sources", "Repos");
+}
+function getSourceRepositoryPath(flintPath, name) {
+  const kebabName = toKebabCase(name);
+  return join(getWorkspaceSourceRepositoriesDir(flintPath), kebabName);
+}
+async function cloneSourceRepository(flintPath, name, url) {
+  const repositoriesDir = getWorkspaceSourceRepositoriesDir(flintPath);
+  await mkdir(repositoriesDir, { recursive: true });
+  const repoPath = getSourceRepositoryPath(flintPath, name);
+  if (await pathExists(repoPath)) {
+    throw new Error(`Source repository folder already exists: ${repoPath}`);
+  }
+  try {
+    await execAsync(`git clone --depth 1 "${url}" "${repoPath}"`);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw new Error(`Failed to clone source repository: ${message}`);
+  }
+  const gitDir = join(repoPath, ".git");
+  try {
+    await rm(gitDir, { recursive: true, force: true });
+  } catch {
+  }
+  return repoPath;
+}
+async function removeSourceRepositoryFolder(flintPath, name) {
+  const repoPath = getSourceRepositoryPath(flintPath, name);
+  if (!await pathExists(repoPath)) {
+    return false;
+  }
+  await rm(repoPath, { recursive: true, force: true });
+  return true;
+}
+async function updateSourceRepository(flintPath, name, url) {
+  await removeSourceRepositoryFolder(flintPath, name);
+  return cloneSourceRepository(flintPath, name, url);
+}
+async function getSourceRepositoryStatus(flintPath) {
+  const declarations = await getWorkspaceSourceRepositories(flintPath);
+  const statuses = [];
+  for (const repo of declarations) {
+    const repoPath = getSourceRepositoryPath(flintPath, repo.name);
+    const exists = await pathExists(repoPath);
+    statuses.push({
+      name: repo.name,
+      url: repo.url,
+      status: exists ? "cloned" : "missing",
+      path: repoPath
+    });
+  }
+  return statuses;
+}
+async function readLegacyWorkspaceConfig(flintPath) {
+  const configPath = getLegacyWorkspaceConfigPath(flintPath);
+  try {
+    const content = await readFile(configPath, "utf-8");
+    return parse(content);
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      return {};
+    }
+    throw error;
+  }
+}
+async function legacyWorkspaceConfigExists(flintPath) {
+  try {
+    await access(getLegacyWorkspaceConfigPath(flintPath));
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function migrateWorkspaceConfig(flintPath) {
+  const result = { migrated: [], removed: false };
+  if (!await legacyWorkspaceConfigExists(flintPath)) {
+    return result;
+  }
+  const legacyConfig = await readLegacyWorkspaceConfig(flintPath);
+  if (Object.keys(legacyConfig).length === 0) {
+    try {
+      await unlink(getLegacyWorkspaceConfigPath(flintPath));
+      result.removed = true;
+    } catch {
+    }
+    return result;
+  }
+  for (const [name, entry] of Object.entries(legacyConfig)) {
+    if (entry && typeof entry === "object" && "path" in entry) {
+      await generateReferenceMetadata(flintPath, { name, type: "codebase" });
+      await updateReferenceState(flintPath, name, "codebase", entry.path);
+      result.migrated.push(name);
+    }
+  }
+  try {
+    await unlink(getLegacyWorkspaceConfigPath(flintPath));
+    result.removed = true;
+  } catch {
+  }
+  return result;
+}
+
+export {
+  getWorkspaceReferencesDir,
+  getWorkspaceReferenceFilePath,
+  getLegacyWorkspaceConfigPath,
+  getLegacyWorkspaceDir,
+  getReferencesStatePath,
+  readReferencesState,
+  writeReferencesState,
+  updateReferenceState,
+  removeReferenceState,
+  readReferencePath,
+  writeReferenceFile,
+  deleteReferenceFile,
+  getWorkspaceStatus,
+  getUnfulfilledWorkspaces,
+  setWorkspacePath,
+  removeWorkspacePath,
+  getWorkspacePath,
+  getWorkspaceRepositoriesDir,
+  getRepositoryPath,
+  createRepository,
+  cloneRepository,
+  removeRepositoryFolder,
+  updateRepository,
+  freshCloneRepository,
+  getRepositoryStatus,
+  getWorkspaceSourceRepositoriesDir,
+  getSourceRepositoryPath,
+  cloneSourceRepository,
+  removeSourceRepositoryFolder,
+  updateSourceRepository,
+  getSourceRepositoryStatus,
+  migrateWorkspaceConfig
+};

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

@@ -1,6 +1,6 @@
-// ../../packages/flint/dist/chunk-2WZYXQX5.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,8 +828,9 @@ function stringify(obj, { maxDepth = 1e3, numbersAsFloat = false } = {}) {
   return str;
 }
 
-// ../../packages/flint/dist/chunk-2WZYXQX5.js
+// ../../packages/flint/dist/chunk-HP5CLO2G.js
 import { randomUUID } from "crypto";
+var join = pathJoin;
 function resolveShardMode(decl) {
   return decl.mode;
 }
@@ -839,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, "");
 }
@@ -869,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() {
@@ -1018,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) => {
@@ -1078,15 +1055,13 @@ function formatFlintToml(config) {
     lines.push(`remote = ${tv(config.git.remote)}`);
     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.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", "mods", "exports", "imports", "workspace", "connections", "git", "lattices"]);
+  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 = {};
@@ -1138,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 [];
@@ -1376,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) {
@@ -1524,11 +1496,6 @@ export {
   writeFlintToml,
   addShardToConfig,
   removeShardFromConfig,
-  addModToConfig,
-  removeModFromConfig,
-  getModDeclarationsFromConfig,
-  getModDeclarations,
-  migrateModConfig,
   getRequiredShardNames,
   getShardDeclarationsFromConfig,
   getShardDeclarations,
@@ -1547,6 +1514,13 @@ export {
   removeWorkspaceSourceRepository,
   getWorkspaceSourceRepositories,
   getWorkspaceSourceRepository,
+  readLatticesState,
+  addLatticeDeclaration,
+  removeLatticeDeclaration,
+  fulfillLattice,
+  getLatticeDeclarations,
+  getLatticeDeclaration,
+  getLatticeFulfillment,
   addLatticeReference,
   removeLatticeReference,
   getLatticeReferences,