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

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

@@ -1,4 +1,4 @@
-// ../../packages/flint/dist/chunk-E7CDAGZD.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-VGFSHC2G-YCC4ZIAT.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-VGFSHC2G-YCC4ZIAT.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())
@@ -319,13 +284,15 @@ async function buildExport(manifest, flintPath) {
   const resolvedFiles = [];
   const processedPaths = /* @__PURE__ */ new Set();
   processedPaths.add(manifest.sourcePath);
-  for (const docRef of manifest.files) {
-    const sourcePath = await resolveDocument(docRef, flintPath);
-    if (!sourcePath || processedPaths.has(sourcePath)) continue;
-    resolvedFiles.push({ sourcePath, docRef });
-    processedPaths.add(sourcePath);
-  }
   const depth = manifest.depth;
+  if (depth === -1 || depth > 0) {
+    for (const docRef of manifest.files) {
+      const sourcePath = await resolveDocument(docRef, flintPath);
+      if (!sourcePath || processedPaths.has(sourcePath)) continue;
+      resolvedFiles.push({ sourcePath, docRef });
+      processedPaths.add(sourcePath);
+    }
+  }
   const allReferencedFiles = /* @__PURE__ */ new Set();
   const exportContent = await readFile(manifest.sourcePath, "utf-8");
   await collectReferencedFiles(exportContent, flintPath, allReferencedFiles, new Set(processedPaths), depth, 0);
@@ -340,7 +307,7 @@ async function buildExport(manifest, flintPath) {
     }
   }
   const allExportFiles = [
-    { sourcePath: manifest.sourcePath, baseName: manifest.name },
+    { sourcePath: manifest.sourcePath, baseName: basename(manifest.sourcePath, ".md") },
     ...resolvedFiles.map((f) => ({ sourcePath: f.sourcePath, baseName: basename(f.sourcePath, ".md") }))
   ];
   const baseNameCounts = /* @__PURE__ */ new Map();
@@ -382,6 +349,7 @@ async function buildExport(manifest, flintPath) {
   const manifestJson = {
     name: manifest.name,
     flint: flintName,
+    rootFile: rootFileName,
     builtAt: (/* @__PURE__ */ new Date()).toISOString(),
     files: copiedFiles
   };

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

@@ -1,4 +1,4 @@
-// ../../packages/flint/dist/chunk-CJE24DAP.js
+// ../../packages/flint/dist/chunk-X3YVJP3U.js
 import { mkdir, readFile, writeFile } from "fs/promises";
 import { homedir } from "os";
 import { join, resolve } from "path";
@@ -58,13 +58,14 @@ async function findFlintByPath(path) {
   const flints = await getFlintRegistry();
   return flints.find((f) => f.path === resolvedPath) ?? null;
 }
-async function findFlintById(_id) {
-  return null;
-}
 async function findFlintByName(name) {
   const flints = await getFlintRegistry();
   return flints.find((f) => f.name === name) ?? null;
 }
+async function isFlintNameTaken(name) {
+  const flints = await getFlintRegistry();
+  return flints.find((f) => f.name === name);
+}
 async function upsertFlintEntry(entry) {
   const normalizedEntry = { ...entry, path: resolve(entry.path) };
   const flints = await getFlintRegistry();
@@ -158,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;
     }
@@ -184,7 +182,7 @@ async function cleanRegistryFile() {
   return result;
 }
 async function registerFlintByPath(path, options) {
-  const { readFlintToml, hasFlintToml } = await import("./mesh-config-VGFSHC2G-YCC4ZIAT.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}
@@ -195,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}`);
@@ -203,7 +200,6 @@ Missing flint.toml`);
   const entry = {
     name,
     path,
-    type,
     source: "local"
   };
   if (toml.flint.tags && toml.flint.tags.length > 0) {
@@ -223,8 +219,8 @@ export {
   registerFlint,
   unregisterFlint,
   findFlintByPath,
-  findFlintById,
   findFlintByName,
+  isFlintNameTaken,
   upsertFlintEntry,
   updateFlintEntry,
   isPathRegistered,

package/dist/chunk-T7VT4BN3.js

@@ -0,0 +1,303 @@
+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/chunk-V7YA5RXL.js

@@ -0,0 +1,43 @@
+// ../../packages/flint/dist/chunk-STM4NXTT.js
+import { access } from "fs/promises";
+async function exists(path) {
+  try {
+    await access(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function runConcurrent(tasks, options = {}) {
+  const { concurrency = 10, onComplete, onError, onStart } = options;
+  const results = [];
+  if (tasks.length === 0) return results;
+  let taskIdx = 0;
+  async function runNext() {
+    while (taskIdx < tasks.length) {
+      const idx = taskIdx++;
+      const task = tasks[idx];
+      onStart?.(task.name);
+      try {
+        const value = await task.run();
+        results.push({ name: task.name, status: "ok", value });
+        onComplete?.(task.name, value);
+      } catch (err) {
+        const error = err instanceof Error ? err : new Error(String(err));
+        results.push({ name: task.name, status: "error", error });
+        onError?.(task.name, error);
+      }
+    }
+  }
+  const workers = [];
+  for (let i = 0; i < Math.min(concurrency, tasks.length); i++) {
+    workers.push(runNext());
+  }
+  await Promise.all(workers);
+  return results;
+}
+
+export {
+  exists,
+  runConcurrent
+};

package/dist/connections-AXGFYQOK-A6BXCAC7.js

@@ -0,0 +1,43 @@
+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/{exports-CA5QHVI7-6IDFKMCF.js → exports-B5CYVV5M-KF36KYYW.js}

@@ -5,7 +5,7 @@ import {
   cleanupStaleExports,
   scanExportEligible,
   scanExports
-} from "./chunk-VO4ZYDCW.js";
+} from "./chunk-ODSWKVNZ.js";
 export {
   buildAllExports,
   buildExport,