@factorialco/fcode-cli 2.3.0 → 3.0.0

package/dist/utils/diff.d.ts

@@ -0,0 +1,19 @@
+export declare const DEV_NULL = "/dev/null";
+/**
+ * One comparable artifact of a resource, named after the file it is stored in. A side left
+ * undefined does not exist there (a process only in the cloud, a module only on disk); an empty
+ * string is a file that exists and is empty, which is a different thing and diffs differently.
+ */
+export type PseudoFile = {
+    path: string;
+    remote?: string;
+    local?: string;
+};
+export declare const hasDifference: (file: PseudoFile) => boolean;
+/**
+ * A unified diff of one pseudo-file, remote as the old side and local as the new one, so the
+ * patch reads as what a push would apply to the cloud. Empty when the sides are equal.
+ */
+export declare function renderUnifiedDiff(file: PseudoFile): string;
+/** Colors a rendered patch the way git does. Chalk no-ops when the output is not a TTY. */
+export declare function colorizeDiff(patch: string): string;

package/dist/utils/diff.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hasDifference = exports.DEV_NULL = void 0;
+exports.renderUnifiedDiff = renderUnifiedDiff;
+exports.colorizeDiff = colorizeDiff;
+const diff_1 = require("diff");
+const chalk = require("chalk");
+exports.DEV_NULL = '/dev/null';
+const hasDifference = (file) => file.remote !== file.local;
+exports.hasDifference = hasDifference;
+/**
+ * A hunk range the way git writes one: the count is left out when it is 1, and an empty range
+ * points at the line it would be inserted after, so a whole-file addition reads `-0,0`.
+ */
+function formatRange(start, lines) {
+    if (lines === 1) {
+        return `${start}`;
+    }
+    return `${lines === 0 ? start - 1 : start},${lines}`;
+}
+/**
+ * A unified diff of one pseudo-file, remote as the old side and local as the new one, so the
+ * patch reads as what a push would apply to the cloud. Empty when the sides are equal.
+ */
+function renderUnifiedDiff(file) {
+    if (!(0, exports.hasDifference)(file)) {
+        return '';
+    }
+    const oldName = file.remote === undefined ? exports.DEV_NULL : `remote/${file.path}`;
+    const newName = file.local === undefined ? exports.DEV_NULL : `local/${file.path}`;
+    const { hunks } = (0, diff_1.structuredPatch)(oldName, newName, file.remote ?? '', file.local ?? '', undefined, undefined, { context: 3 });
+    const lines = [`--- ${oldName}`, `+++ ${newName}`];
+    for (const hunk of hunks) {
+        lines.push(`@@ -${formatRange(hunk.oldStart, hunk.oldLines)} +${formatRange(hunk.newStart, hunk.newLines)} @@`, ...hunk.lines);
+    }
+    return lines.join('\n');
+}
+/** Colors a rendered patch the way git does. Chalk no-ops when the output is not a TTY. */
+function colorizeDiff(patch) {
+    return patch
+        .split('\n')
+        .map((line) => {
+        if (line.startsWith('---') || line.startsWith('+++')) {
+            return chalk.bold(line);
+        }
+        if (line.startsWith('@@')) {
+            return chalk.cyan(line);
+        }
+        if (line.startsWith('+')) {
+            return chalk.green(line);
+        }
+        if (line.startsWith('-')) {
+            return chalk.red(line);
+        }
+        return line;
+    })
+        .join('\n');
+}

package/dist/utils/gitignore.d.ts

@@ -1,5 +1,6 @@
 export declare const INHERITED_BLOCK_START = "# BEGIN fcode inherited resources (auto-generated, do not edit)";
 export declare const INHERITED_BLOCK_END = "# END fcode inherited resources";
+export declare const INHERITED_DEPENDENCY_FILES: string[];
 /**
  * Rebuilds the managed "inherited resources" block in a .gitignore.
  *
@@ -14,6 +15,7 @@ export declare function renderGitignoreWithInherited(existing: string, inherited
  * parent team and pulled read-only) are not tracked by git. Regenerated from the
  * current workspace metadata, so resources that stop being inherited drop out.
  * Inherited variable values live in one file, which is ignored as soon as the
- * workspace inherits any variable; inherited locales are one file each, like modules.
+ * workspace inherits any variable; inherited locales are one file each, like modules;
+ * inherited dependencies are one file per language, like variables.
  */
 export declare function syncInheritedGitignore(workspaceDir?: string): Promise<void>;

package/dist/utils/gitignore.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.INHERITED_BLOCK_END = exports.INHERITED_BLOCK_START = void 0;
+exports.INHERITED_DEPENDENCY_FILES = exports.INHERITED_BLOCK_END = exports.INHERITED_BLOCK_START = void 0;
 exports.renderGitignoreWithInherited = renderGitignoreWithInherited;
 exports.syncInheritedGitignore = syncInheritedGitignore;
 const path = require("node:path");
@@ -8,10 +8,14 @@ const fs = require("fs-extra");
 const workspace_1 = require("../config/workspace");
 const global_1 = require("../config/global");
 const settings_1 = require("../config/settings");
+const programming_language_manifest_1 = require("../repositories/programming-language-manifest");
 const filenamify_1 = require("./filenamify");
 const file_utils_1 = require("./file-utils");
 exports.INHERITED_BLOCK_START = '# BEGIN fcode inherited resources (auto-generated, do not edit)';
 exports.INHERITED_BLOCK_END = '# END fcode inherited resources';
+// Derived from the repository that writes them, so renaming a file cannot silently stop it being
+// gitignored.
+exports.INHERITED_DEPENDENCY_FILES = Object.values(programming_language_manifest_1.INHERITED_FILE_NAME).map((name) => `${programming_language_manifest_1.DEPENDENCIES_DIR}/${name}`);
 /**
  * Rebuilds the managed "inherited resources" block in a .gitignore.
  *
@@ -46,7 +50,8 @@ function stripManagedBlock(content) {
  * parent team and pulled read-only) are not tracked by git. Regenerated from the
  * current workspace metadata, so resources that stop being inherited drop out.
  * Inherited variable values live in one file, which is ignored as soon as the
- * workspace inherits any variable; inherited locales are one file each, like modules.
+ * workspace inherits any variable; inherited locales are one file each, like modules;
+ * inherited dependencies are one file per language, like variables.
  */
 async function syncInheritedGitignore(workspaceDir = process.cwd()) {
     const team = await new workspace_1.default(workspaceDir).getActiveTeam();
@@ -62,6 +67,10 @@ async function syncInheritedGitignore(workspaceDir = process.cwd()) {
         ...Object.values(team.i18n ?? {})
             .filter((locale) => locale.resolvingTeamSlug)
             .map((locale) => `i18n/${(0, filenamify_1.default)(locale.slug)}.yaml`),
+        // Inherited dependencies are one file per language, written only when there is something to
+        // inherit — checked on disk because the manifest metadata tracks the workspace's own list, not
+        // what its parents contribute.
+        ...exports.INHERITED_DEPENDENCY_FILES.filter((file) => fs.existsSync(path.join(workspaceDir, file))),
     ];
     const gitignorePath = path.join(workspaceDir, '.gitignore');
     const existing = fs.existsSync(gitignorePath) ? fs.readFileSync(gitignorePath, 'utf8') : '';

package/dist/utils/slugify.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Folder name for a development team or an App, derived from its display name. Names are free
+ * text — accents, punctuation, emoji — while the folder has to be portable and typeable, so
+ * everything outside `[a-z0-9-]` collapses into a single dash.
+ */
+export declare function slugify(name: string): string;
+/**
+ * `slugify` with a fallback, so a name written entirely in a non-latin script still yields a
+ * usable folder instead of an empty one.
+ */
+export declare function slugifyOr(name: string, fallback: string): string;
+/**
+ * The first claimant of a slug keeps it; the next ones get `-2`, `-3`… Callers assign folders in a
+ * stable order (by app id), so the same team always produces the same layout — and once assigned,
+ * the folder is recorded in the team metadata and never derived again.
+ */
+export declare function uniqueSlug(slug: string, taken: Set<string>): string;

package/dist/utils/slugify.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.slugify = slugify;
+exports.slugifyOr = slugifyOr;
+exports.uniqueSlug = uniqueSlug;
+/**
+ * Folder name for a development team or an App, derived from its display name. Names are free
+ * text — accents, punctuation, emoji — while the folder has to be portable and typeable, so
+ * everything outside `[a-z0-9-]` collapses into a single dash.
+ */
+function slugify(name) {
+    return name
+        .normalize('NFKD')
+        .replaceAll(/[̀-ͯ]/g, '')
+        .replaceAll(/[^a-zA-Z\d]+/g, '-')
+        .replaceAll(/^-+|-+$/g, '')
+        .toLowerCase();
+}
+/**
+ * `slugify` with a fallback, so a name written entirely in a non-latin script still yields a
+ * usable folder instead of an empty one.
+ */
+function slugifyOr(name, fallback) {
+    const slug = slugify(name);
+    return slug.length > 0 ? slug : fallback;
+}
+/**
+ * The first claimant of a slug keeps it; the next ones get `-2`, `-3`… Callers assign folders in a
+ * stable order (by app id), so the same team always produces the same layout — and once assigned,
+ * the folder is recorded in the team metadata and never derived again.
+ */
+function uniqueSlug(slug, taken) {
+    if (!taken.has(slug)) {
+        return slug;
+    }
+    let suffix = 2;
+    while (taken.has(`${slug}-${suffix}`)) {
+        suffix += 1;
+    }
+    return `${slug}-${suffix}`;
+}