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

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/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-KXKBTYJ2-A3QWNDEB.js → exports-B5CYVV5M-KF36KYYW.js}

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