@nuucognition/flint-cli 0.1.0-beta.0

package/dist/chunk-F5Q2BJFK.js

@@ -0,0 +1,233 @@
+// ../../packages/flint/src/registry.ts
+import { mkdir, readFile, writeFile } from "fs/promises";
+import { homedir } from "os";
+import { join, resolve } from "path";
+var REGISTRY_VERSION = 1;
+function getGlobalFlintDir() {
+  return join(homedir(), ".flint");
+}
+function getFlintRegistryPath() {
+  return join(getGlobalFlintDir(), "registry.json");
+}
+async function ensureRegistryDir() {
+  await mkdir(getGlobalFlintDir(), { recursive: true });
+}
+function createEmptyRegistry() {
+  return {
+    version: REGISTRY_VERSION,
+    flints: []
+  };
+}
+async function getFlintRegistry() {
+  try {
+    const content = await readFile(getFlintRegistryPath(), "utf-8");
+    const registry = JSON.parse(content);
+    return registry.flints;
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      return [];
+    }
+    throw error;
+  }
+}
+async function saveRegistry(registry) {
+  await ensureRegistryDir();
+  await writeFile(getFlintRegistryPath(), JSON.stringify(registry, null, 2));
+}
+async function registerFlint(entry) {
+  const normalizedEntry = { ...entry, path: resolve(entry.path) };
+  const flints = await getFlintRegistry();
+  const existing = flints.find((f) => f.path === normalizedEntry.path);
+  if (existing) {
+    throw new Error(`Flint already registered at path: ${entry.path}`);
+  }
+  flints.push(normalizedEntry);
+  await saveRegistry({ version: REGISTRY_VERSION, flints });
+}
+async function unregisterFlint(path) {
+  const resolvedPath = resolve(path);
+  const flints = await getFlintRegistry();
+  const filtered = flints.filter((f) => f.path !== resolvedPath);
+  if (filtered.length === flints.length) {
+    throw new Error(`Flint not found at path: ${path}`);
+  }
+  await saveRegistry({ version: REGISTRY_VERSION, flints: filtered });
+}
+async function findFlintByPath(path) {
+  const resolvedPath = resolve(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 upsertFlintEntry(entry) {
+  const normalizedEntry = { ...entry, path: resolve(entry.path) };
+  const flints = await getFlintRegistry();
+  const indexByPath = flints.findIndex((f) => f.path === normalizedEntry.path);
+  if (indexByPath !== -1) {
+    flints[indexByPath] = normalizedEntry;
+  } else {
+    flints.push(normalizedEntry);
+  }
+  await saveRegistry({ version: REGISTRY_VERSION, flints });
+}
+async function updateFlintEntry(path, updates) {
+  const resolvedPath = resolve(path);
+  const flints = await getFlintRegistry();
+  const entry = flints.find((f) => f.path === resolvedPath);
+  if (!entry) {
+    throw new Error(`Flint not found at path: ${path}`);
+  }
+  Object.assign(entry, updates);
+  await saveRegistry({ version: REGISTRY_VERSION, flints });
+}
+async function isPathRegistered(path) {
+  const resolvedPath = resolve(path);
+  const flints = await getFlintRegistry();
+  return flints.some((f) => f.path === resolvedPath);
+}
+async function cleanRegistryFile() {
+  const result = {
+    entriesCleaned: 0,
+    invalidEntriesRemoved: 0,
+    modified: false,
+    details: []
+  };
+  let rawContent;
+  try {
+    rawContent = await readFile(getFlintRegistryPath(), "utf-8");
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      return result;
+    }
+    throw error;
+  }
+  let registry;
+  try {
+    registry = JSON.parse(rawContent);
+  } catch {
+    result.details.push("Registry file was corrupted, creating fresh registry");
+    result.modified = true;
+    await saveRegistry(createEmptyRegistry());
+    return result;
+  }
+  if (!registry || typeof registry !== "object") {
+    result.details.push("Registry file had invalid structure, creating fresh registry");
+    result.modified = true;
+    await saveRegistry(createEmptyRegistry());
+    return result;
+  }
+  if (!Array.isArray(registry.flints)) {
+    registry.flints = [];
+    result.details.push("Registry was missing flints array");
+    result.modified = true;
+  }
+  const cleanedFlints = [];
+  const deprecatedFields = ["id", "created"];
+  for (const rawEntry of registry.flints) {
+    if (!rawEntry || typeof rawEntry !== "object") {
+      result.invalidEntriesRemoved++;
+      result.details.push("Removed invalid non-object entry");
+      result.modified = true;
+      continue;
+    }
+    const entry = rawEntry;
+    if (typeof entry.name !== "string" || typeof entry.path !== "string") {
+      result.invalidEntriesRemoved++;
+      result.details.push(`Removed invalid entry missing name or path`);
+      result.modified = true;
+      continue;
+    }
+    let hadDeprecatedFields = false;
+    for (const field of deprecatedFields) {
+      if (field in entry) {
+        delete entry[field];
+        hadDeprecatedFields = true;
+      }
+    }
+    if (hadDeprecatedFields) {
+      result.entriesCleaned++;
+      result.modified = true;
+    }
+    const cleanEntry = {
+      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;
+    }
+    if (Array.isArray(entry.tags)) {
+      cleanEntry.tags = entry.tags.filter((t) => typeof t === "string");
+    }
+    if (typeof entry.description === "string") {
+      cleanEntry.description = entry.description;
+    }
+    if (Array.isArray(entry.exports)) {
+      cleanEntry.exports = entry.exports.filter((e) => typeof e === "string");
+    }
+    cleanedFlints.push(cleanEntry);
+  }
+  if (result.modified) {
+    await saveRegistry({ version: REGISTRY_VERSION, flints: cleanedFlints });
+    if (result.entriesCleaned > 0) {
+      result.details.push(`Removed deprecated fields from ${result.entriesCleaned} entries`);
+    }
+  }
+  return result;
+}
+async function registerFlintByPath(path, options) {
+  const { readFlintToml, hasFlintToml } = await import("./mesh-config-O3UKKKAO.js");
+  const isFlint = await hasFlintToml(path);
+  if (!isFlint) {
+    throw new Error(`Not a valid flint: ${path}
+Missing flint.toml`);
+  }
+  const toml = await readFlintToml(path);
+  if (!toml || !toml.flint?.name) {
+    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}`);
+  }
+  const entry = {
+    name,
+    path,
+    type,
+    source: "local"
+  };
+  if (toml.flint.tags && toml.flint.tags.length > 0) {
+    entry.tags = toml.flint.tags;
+  }
+  if (toml.flint.description) {
+    entry.description = toml.flint.description;
+  }
+  await upsertFlintEntry(entry);
+  return entry;
+}
+
+export {
+  getGlobalFlintDir,
+  getFlintRegistryPath,
+  getFlintRegistry,
+  registerFlint,
+  unregisterFlint,
+  findFlintByPath,
+  findFlintById,
+  findFlintByName,
+  upsertFlintEntry,
+  updateFlintEntry,
+  isPathRegistered,
+  cleanRegistryFile,
+  registerFlintByPath
+};

package/dist/exports-Y3NVZFFT.js

@@ -0,0 +1,14 @@
+import {
+  buildAllExports,
+  buildExport,
+  buildExportByName,
+  cleanupStaleExports,
+  scanExports
+} from "./chunk-BVYUS7NX.js";
+export {
+  buildAllExports,
+  buildExport,
+  buildExportByName,
+  cleanupStaleExports,
+  scanExports
+};

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+
+export {  }