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

package/dist/chunk-KVE7WLA2.js

@@ -1,297 +0,0 @@
-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-T7VT4BN3.js

@@ -1,303 +0,0 @@
-import {
-  generateConnectionMetadata,
-  getConnectionMetadataPath,
-  getConnectionsMetadataDir,
-  getFlintConfigDir
-} from "./chunk-KVE7WLA2.js";
-import {
-  readFlintToml,
-  writeFlintToml
-} from "./chunk-KLFK7CPM.js";
-import {
-  findFlintByName
-} from "./chunk-OIXBMYAA.js";
-
-// ../../packages/flint/dist/chunk-AUWQSMUZ.js
-import { readFile, writeFile, mkdir, access, rm } from "fs/promises";
-import { join as join2 } from "path";
-import { stat } from "fs/promises";
-import { dirname, join } from "path";
-async function findFlintRoot(startPath) {
-  let current = startPath;
-  if (!current.startsWith("/")) {
-    current = join(process.cwd(), current);
-  }
-  while (current !== dirname(current)) {
-    const flintConfigDir = join(current, ".flint");
-    const flintToml = join(current, "flint.toml");
-    try {
-      const configStat = await stat(flintConfigDir);
-      if (configStat.isDirectory()) {
-        return current;
-      }
-    } catch {
-    }
-    try {
-      const tomlStat = await stat(flintToml);
-      if (tomlStat.isFile()) {
-        return current;
-      }
-    } catch {
-    }
-    current = dirname(current);
-  }
-  return null;
-}
-async function isInsideFlint(path) {
-  const flintRoot = await findFlintRoot(path);
-  return flintRoot !== null;
-}
-function getConnectionsDir(flintPath) {
-  return getConnectionsMetadataDir(flintPath);
-}
-function getConnectionDir(flintPath, _name) {
-  return getConnectionsMetadataDir(flintPath);
-}
-function getConnectionsStatePath(flintPath) {
-  return join2(getFlintConfigDir(flintPath), "connections.json");
-}
-function getConnectionFilePath(flintPath, name) {
-  return getConnectionMetadataPath(flintPath, name);
-}
-async function readConnectionsState(flintPath) {
-  try {
-    const content = await readFile(getConnectionsStatePath(flintPath), "utf-8");
-    return JSON.parse(content);
-  } catch {
-    return { version: 1, connections: [] };
-  }
-}
-async function writeConnectionsState(flintPath, state) {
-  const statePath = getConnectionsStatePath(flintPath);
-  await mkdir(getFlintConfigDir(flintPath), { recursive: true });
-  await writeFile(statePath, JSON.stringify(state, null, 2));
-}
-async function getConnectionDeclarations(flintPath) {
-  const config = await readFlintToml(flintPath);
-  return config?.connections?.flints || [];
-}
-async function addConnectionDeclaration(flintPath, name) {
-  const registeredFlint = await findFlintByName(name);
-  if (!registeredFlint) {
-    throw new Error(
-      `"${name}" is not a registered Flint. Use 'flint list' to see registered Flints, or 'flint register <path>' to register it first.`
-    );
-  }
-  const config = await readFlintToml(flintPath);
-  if (!config) {
-    throw new Error("Could not read flint.toml");
-  }
-  if (!config.connections) {
-    config.connections = { flints: [] };
-  }
-  if (!config.connections.flints) {
-    config.connections.flints = [];
-  }
-  const existing = config.connections.flints.find(
-    (c) => c.name.toLowerCase() === name.toLowerCase()
-  );
-  if (existing) {
-    throw new Error(`Connection to "${name}" is already declared`);
-  }
-  config.connections.flints.push({ name });
-  await writeFlintToml(flintPath, config);
-}
-async function removeConnectionDeclaration(flintPath, name) {
-  const config = await readFlintToml(flintPath);
-  if (!config?.connections?.flints) return false;
-  const normalizedName = name.toLowerCase();
-  const index = config.connections.flints.findIndex(
-    (c) => c.name.toLowerCase() === normalizedName
-  );
-  if (index === -1) return false;
-  config.connections.flints.splice(index, 1);
-  if (config.connections.flints.length === 0) {
-    delete config.connections.flints;
-  }
-  if (Object.keys(config.connections).length === 0) {
-    delete config.connections;
-  }
-  await writeFlintToml(flintPath, config);
-  return true;
-}
-async function fulfillConnection(flintPath, name, targetPath) {
-  const declarations = await getConnectionDeclarations(flintPath);
-  const declaration = declarations.find(
-    (d) => d.name.toLowerCase() === name.toLowerCase()
-  );
-  if (!declaration) {
-    throw new Error(
-      `Connection "${name}" is not declared. Use 'flint connection add "${name}"' first.`
-    );
-  }
-  let resolvedPath = targetPath;
-  if (!resolvedPath) {
-    const registeredFlint = await findFlintByName(name);
-    if (!registeredFlint) {
-      throw new Error(
-        `"${name}" is not in the registry. Provide a path explicitly or register the Flint first.`
-      );
-    }
-    resolvedPath = registeredFlint.path;
-  }
-  const isFlint = await isInsideFlint(resolvedPath);
-  if (!isFlint) {
-    throw new Error(`Target is not a valid Flint: ${resolvedPath}`);
-  }
-  const fulfillment = {
-    name: declaration.name,
-    // Use declared name (proper case)
-    path: resolvedPath,
-    fulfilled: (/* @__PURE__ */ new Date()).toISOString()
-  };
-  const state = await readConnectionsState(flintPath);
-  const existingIndex = state.connections.findIndex(
-    (c) => c.name.toLowerCase() === name.toLowerCase()
-  );
-  if (existingIndex >= 0) {
-    state.connections[existingIndex] = fulfillment;
-  } else {
-    state.connections.push(fulfillment);
-  }
-  await writeConnectionsState(flintPath, state);
-  return fulfillment;
-}
-async function unfulfillConnection(flintPath, name) {
-  const normalizedName = name.toLowerCase();
-  const state = await readConnectionsState(flintPath);
-  const index = state.connections.findIndex(
-    (c) => c.name.toLowerCase() === normalizedName
-  );
-  if (index >= 0) {
-    state.connections.splice(index, 1);
-    await writeConnectionsState(flintPath, state);
-    return true;
-  }
-  return false;
-}
-async function getConnectionStatus(flintPath) {
-  const declarations = await getConnectionDeclarations(flintPath);
-  const state = await readConnectionsState(flintPath);
-  const results = [];
-  for (const declaration of declarations) {
-    const fulfillment = state.connections.find(
-      (c) => c.name.toLowerCase() === declaration.name.toLowerCase()
-    );
-    const status = {
-      name: declaration.name,
-      declared: true,
-      fulfilled: !!fulfillment
-    };
-    if (fulfillment) {
-      status.path = fulfillment.path;
-      status.fulfilledAt = fulfillment.fulfilled;
-      try {
-        await access(fulfillment.path);
-        const isFlint = await isInsideFlint(fulfillment.path);
-        status.valid = isFlint;
-      } catch {
-        status.valid = false;
-      }
-    }
-    results.push(status);
-  }
-  return results;
-}
-async function getConnection(flintPath, name) {
-  const statuses = await getConnectionStatus(flintPath);
-  return statuses.find((s) => s.name.toLowerCase() === name.toLowerCase()) || null;
-}
-async function listConnections(flintPath) {
-  return getConnectionStatus(flintPath);
-}
-async function getUnfulfilledConnections(flintPath) {
-  const statuses = await getConnectionStatus(flintPath);
-  return statuses.filter((s) => !s.fulfilled).map((s) => ({ name: s.name }));
-}
-async function addConnection(flintPath, name, autoFulfill = true) {
-  await addConnectionDeclaration(flintPath, name);
-  await generateConnectionMetadata(flintPath, { name });
-  if (autoFulfill) {
-    try {
-      await fulfillConnection(flintPath, name);
-    } catch {
-    }
-  }
-  const status = await getConnection(flintPath, name);
-  if (!status) {
-    throw new Error("Failed to add connection");
-  }
-  return status;
-}
-async function removeConnection(flintPath, name) {
-  await unfulfillConnection(flintPath, name);
-  try {
-    const metadataPath = getConnectionMetadataPath(flintPath, name);
-    await rm(metadataPath);
-  } catch {
-  }
-  return removeConnectionDeclaration(flintPath, name);
-}
-async function migrateConnections(flintPath) {
-  const result = { migrated: 0, errors: [] };
-  try {
-    const oldConfigPath = getConnectionsStatePath(flintPath);
-    const oldContent = await readFile(oldConfigPath, "utf-8");
-    const oldConfig = JSON.parse(oldContent);
-    if (!oldConfig.connections || oldConfig.connections.length === 0) {
-      return result;
-    }
-    const firstConnection = oldConfig.connections[0];
-    if (!firstConnection.path) {
-      return result;
-    }
-    for (const oldEntry of oldConfig.connections) {
-      try {
-        await addConnectionDeclaration(flintPath, oldEntry.name);
-        await generateConnectionMetadata(flintPath, { name: oldEntry.name });
-        await fulfillConnection(flintPath, oldEntry.name, oldEntry.path);
-        const oldConnectionDir = join2(flintPath, "Connections", oldEntry.name);
-        const oldFolders = ["inbox", "outbox", "mirror"];
-        for (const folder of oldFolders) {
-          try {
-            await rm(join2(oldConnectionDir, folder), { recursive: true });
-          } catch {
-          }
-        }
-        try {
-          await rm(join2(oldConnectionDir, "connection.md"));
-        } catch {
-        }
-        result.migrated++;
-      } catch (err) {
-        result.errors.push(
-          `Failed to migrate "${oldEntry.name}": ${err instanceof Error ? err.message : String(err)}`
-        );
-      }
-    }
-  } catch {
-  }
-  return result;
-}
-
-export {
-  findFlintRoot,
-  getConnectionsDir,
-  getConnectionDir,
-  getConnectionsStatePath,
-  getConnectionFilePath,
-  readConnectionsState,
-  writeConnectionsState,
-  getConnectionDeclarations,
-  addConnectionDeclaration,
-  removeConnectionDeclaration,
-  fulfillConnection,
-  unfulfillConnection,
-  getConnectionStatus,
-  getConnection,
-  listConnections,
-  getUnfulfilledConnections,
-  addConnection,
-  removeConnection,
-  migrateConnections
-};

package/dist/connections-AXGFYQOK-A6BXCAC7.js

@@ -1,43 +0,0 @@
-import {
-  addConnection,
-  addConnectionDeclaration,
-  fulfillConnection,
-  getConnection,
-  getConnectionDeclarations,
-  getConnectionDir,
-  getConnectionFilePath,
-  getConnectionStatus,
-  getConnectionsDir,
-  getConnectionsStatePath,
-  getUnfulfilledConnections,
-  listConnections,
-  migrateConnections,
-  readConnectionsState,
-  removeConnection,
-  removeConnectionDeclaration,
-  unfulfillConnection,
-  writeConnectionsState
-} from "./chunk-T7VT4BN3.js";
-import "./chunk-KVE7WLA2.js";
-import "./chunk-KLFK7CPM.js";
-import "./chunk-OIXBMYAA.js";
-export {
-  addConnection,
-  addConnectionDeclaration,
-  fulfillConnection,
-  getConnection,
-  getConnectionDeclarations,
-  getConnectionDir,
-  getConnectionFilePath,
-  getConnectionStatus,
-  getConnectionsDir,
-  getConnectionsStatePath,
-  getUnfulfilledConnections,
-  listConnections,
-  migrateConnections,
-  readConnectionsState,
-  removeConnection,
-  removeConnectionDeclaration,
-  unfulfillConnection,
-  writeConnectionsState
-};

package/dist/workspace-local-LKB4MTN2-OY5UVN3K.js

@@ -1,70 +0,0 @@
-import {
-  cloneRepository,
-  cloneSourceRepository,
-  createRepository,
-  deleteReferenceFile,
-  freshCloneRepository,
-  getLegacyWorkspaceConfigPath,
-  getLegacyWorkspaceDir,
-  getReferencesStatePath,
-  getRepositoryPath,
-  getRepositoryStatus,
-  getSourceRepositoryPath,
-  getSourceRepositoryStatus,
-  getUnfulfilledWorkspaces,
-  getWorkspacePath,
-  getWorkspaceReferenceFilePath,
-  getWorkspaceReferencesDir,
-  getWorkspaceRepositoriesDir,
-  getWorkspaceSourceRepositoriesDir,
-  getWorkspaceStatus,
-  migrateWorkspaceConfig,
-  readReferencePath,
-  readReferencesState,
-  removeReferenceState,
-  removeRepositoryFolder,
-  removeSourceRepositoryFolder,
-  removeWorkspacePath,
-  setWorkspacePath,
-  updateReferenceState,
-  updateRepository,
-  updateSourceRepository,
-  writeReferenceFile,
-  writeReferencesState
-} from "./chunk-2Q7QG2UK.js";
-import "./chunk-KVE7WLA2.js";
-import "./chunk-KLFK7CPM.js";
-export {
-  cloneRepository,
-  cloneSourceRepository,
-  createRepository,
-  deleteReferenceFile,
-  freshCloneRepository,
-  getLegacyWorkspaceConfigPath,
-  getLegacyWorkspaceDir,
-  getReferencesStatePath,
-  getRepositoryPath,
-  getRepositoryStatus,
-  getSourceRepositoryPath,
-  getSourceRepositoryStatus,
-  getUnfulfilledWorkspaces,
-  getWorkspacePath,
-  getWorkspaceReferenceFilePath,
-  getWorkspaceReferencesDir,
-  getWorkspaceRepositoriesDir,
-  getWorkspaceSourceRepositoriesDir,
-  getWorkspaceStatus,
-  migrateWorkspaceConfig,
-  readReferencePath,
-  readReferencesState,
-  removeReferenceState,
-  removeRepositoryFolder,
-  removeSourceRepositoryFolder,
-  removeWorkspacePath,
-  setWorkspacePath,
-  updateReferenceState,
-  updateRepository,
-  updateSourceRepository,
-  writeReferenceFile,
-  writeReferencesState
-};