@nuucognition/flint-cli 0.2.0-beta.1 → 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/bin/flint-prod.js

@@ -1,5 +1,7 @@
 #!/usr/bin/env node
 
+process.env.BUILD_MODE = 'prod';
+
 import { fileURLToPath, pathToFileURL } from 'node:url';
 import { dirname, join } from 'node:path';
 

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
+};