@gtkx/cli 1.5.0 → 2.0.0-beta.1

package/src/internal/agent-rules.ts

@@ -0,0 +1,135 @@
+import { readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { REFERENCE_PATH } from "../codegen/reference.js";
+
+type AgentRulesResult = {
+    isWritten: boolean;
+    files: string[];
+};
+
+const AGENTS_FILENAME = "AGENTS.md";
+const CLAUDE_FILENAME = "CLAUDE.md";
+const CLAUDE_CONTENTS = `@${AGENTS_FILENAME}\n`;
+const BEGIN_MARKER = "<!-- BEGIN:gtkx-agent-rules -->";
+const END_MARKER = "<!-- END:gtkx-agent-rules -->";
+const BLOCK_PATTERN = /<!-- BEGIN:gtkx-agent-rules -->[\s\S]*?<!-- END:gtkx-agent-rules -->/;
+const TOP_LEVEL_HEADING = /^# /m;
+
+const rulesBody = (heading: string): string[] => [
+    `${heading} GTKX`,
+    "",
+    "This is not the GTK you have seen before. Most GTK code in your training data is C, PyGObject, Vala or " +
+    "GJS, and almost none of it is valid here. Check the rules below against what you are about to write.",
+    "",
+    "- Children are JSX, never `.append()`, `pack_start()`, `set_child()` or `add()`.",
+    '- Signals are props: `onClicked`, not `widget.connect("clicked", ...)`.',
+    "- Props are camelCase: `marginTop`, not `margin-top` or `margin_top`.",
+    "- There is no `Gtk.Template`, no `.ui` XML, and no `GtkBuilder`. The JSX tree is the definition.",
+    "- Elements come from `@gtkx/jsx/<namespace>` and classes, enums and functions from " +
+    "`@gtkx/gi/<namespace>`. Both are generated for this project by `gtkx codegen`, not installed from npm, " +
+    "so they match the GIR libraries this project declares.",
+    "",
+    `Read \`${REFERENCE_PATH}/index.md\` before writing widget code. It is generated from this project's own ` +
+    "GIR libraries and is the authority on which props, signals and methods exist. Do not infer a prop from " +
+    "another toolkit, from a C function name, or from a similar element.",
+    "",
+    "| Command | What it does |",
+    "| --- | --- |",
+    "| `gtkx dev` | Run the app with fast refresh |",
+    "| `gtkx codegen` | Regenerate bindings and this reference |",
+    "| `tsc --noEmit` | Typecheck |",
+    "| `vitest run` | Run the tests |",
+    "",
+    "Never call UI work done without looking at the running app. With `gtkx dev` up, the gtkx MCP server " +
+    "exposes the live widget tree, queries, clicks and screenshots; use them to confirm the change landed.",
+    "",
+    "This block is written by `gtkx codegen`. Anything outside the markers is yours and is left alone, and " +
+    "committing the block with your work keeps the tree clean.",
+];
+
+const renderBlock = (heading: string): string =>
+    [BEGIN_MARKER, "", ...rulesBody(heading), "", END_MARKER].join("\n");
+
+const headingFor = (contents: string): string => (TOP_LEVEL_HEADING.test(contents) ? "##" : "#");
+const withTrailingNewline = (contents: string): string => (contents.endsWith("\n") ? contents : `${contents}\n`);
+
+const appendBlock = (contents: string, block: string): string => {
+    if (contents.trim() === "") {
+        return `${block}\n`;
+    }
+
+    return `${withTrailingNewline(contents)}\n${block}\n`;
+};
+
+const replaceBlock = (contents: string, block: string): string => {
+    const match = BLOCK_PATTERN.exec(contents);
+
+    if (match === null) {
+        return appendBlock(contents, block);
+    }
+
+    return contents.slice(0, match.index) + block + contents.slice(match.index + match[0].length);
+};
+
+const nextContents = (contents: string): string => {
+    const heading = headingFor(contents.replace(BLOCK_PATTERN, ""));
+
+    return replaceBlock(contents, renderBlock(heading));
+};
+
+const errorCode = (error: unknown): string | undefined =>
+    error instanceof Error ? (error as NodeJS.ErrnoException).code : undefined;
+
+const readOrUndefined = (path: string): string | undefined => {
+    try {
+        return readFileSync(path, "utf8");
+    } catch (error) {
+        if (errorCode(error) === "ENOENT") {
+            return undefined;
+        }
+
+        throw error;
+    }
+};
+
+const hasWritten = (path: string, contents: string): boolean => {
+    if (readOrUndefined(path) === contents) {
+        return false;
+    }
+
+    writeFileSync(path, contents);
+
+    return true;
+};
+
+const hasWrittenClaudeImport = (root: string): boolean => {
+    try {
+        writeFileSync(join(root, CLAUDE_FILENAME), CLAUDE_CONTENTS, { flag: "wx" });
+
+        return true;
+    } catch (error) {
+        if (errorCode(error) === "EEXIST") {
+            return false;
+        }
+
+        throw error;
+    }
+};
+
+const upsertAgentRules = (root: string): AgentRulesResult => {
+    const agentsPath = join(root, AGENTS_FILENAME);
+    const existing = readOrUndefined(agentsPath) ?? "";
+    const files: string[] = [];
+
+    if (hasWritten(agentsPath, nextContents(existing))) {
+        files.push(AGENTS_FILENAME);
+    }
+
+    if (hasWrittenClaudeImport(root)) {
+        files.push(CLAUDE_FILENAME);
+    }
+
+    return { isWritten: files.length > 0, files };
+};
+
+export { upsertAgentRules };

package/src/internal/docs-elements.ts

@@ -0,0 +1,21 @@
+import { type ElementProps, type OmittedProps, readBuiltinElements, resolveStore } from "@gtkx/codegen";
+import { existsSync } from "node:fs";
+
+type DocsElements = {
+    props: ElementProps;
+    omittedProps: OmittedProps;
+};
+
+const resolveDocsElements = async (cwd: string): Promise<DocsElements> => {
+    const { gi } = resolveStore(cwd);
+
+    if (!existsSync(gi.storeDir)) {
+        return { props: {}, omittedProps: {} };
+    }
+
+    const { props, omittedProps } = await readBuiltinElements();
+
+    return { props, omittedProps };
+};
+
+export { resolveDocsElements };

package/src/internal/icon-path.ts

@@ -1,5 +1,6 @@
-import { type Stats, statSync } from "node:fs";
-import { basename, extname, isAbsolute, join, relative, resolve } from "node:path";
+import { isPathInside } from "@gtkx/utils";
+import { statSync } from "node:fs";
+import { basename, extname, isAbsolute, join, resolve } from "node:path";
 
 type ResolvedApplicationIcon = { kind: "file"; path: string } |
     { kind: "none" } |
@@ -10,20 +11,6 @@ const SCALABLE_DIR = "hicolor/scalable/apps";
 const SIZE_PATTERN = /^(?<width>[1-9]\d{0,3})x(?<height>[1-9]\d{0,3})$/;
 const SIZE_SEPARATORS = /[-_.]/;
 
-const isInside = (parent: string, candidate: string): boolean => {
-    const rel = relative(parent, candidate);
-
-    return rel.length > 0 && !rel.startsWith("..") && !isAbsolute(rel);
-};
-
-const getStats = (path: string): Stats | undefined => {
-    try {
-        return statSync(path, { throwIfNoEntry: false });
-    } catch {
-        return undefined;
-    }
-};
-
 const iconExtension = (file: string): string => {
     const extension = extname(file).toLowerCase();
 
@@ -37,7 +24,7 @@ const iconExtension = (file: string): string => {
 const defaultIconFiles = (root: string, applicationId: string): string[] =>
     [...ICON_EXTENSIONS]
         .map((extension) => join(root, `${applicationId}${extension}`))
-        .filter((path) => getStats(path)?.isFile() === true);
+        .filter((path) => statSync(path, { throwIfNoEntry: false })?.isFile() === true);
 
 const resolveDefaultApplicationIcon = (root: string, applicationId: string): ResolvedApplicationIcon => {
     const files = defaultIconFiles(root, applicationId);
@@ -76,11 +63,11 @@ const resolveApplicationIcon = (
 
     const path = resolve(root, configured);
 
-    if (!isInside(root, path)) {
+    if (!isPathInside(root, path)) {
         throw new Error(`Cannot use "${configured}" as the application icon: it is outside ${root}`);
     }
 
-    const stats = getStats(path);
+    const stats = statSync(path, { throwIfNoEntry: false });
 
     if (stats?.isDirectory() === true) {
         return { kind: "theme", path };

package/src/internal/source-imports.ts

@@ -1,6 +1,6 @@
 import type { ESTree, ParseResult, ParserOptions } from "vite";
 import { sortStringsBy } from "@gtkx/utils";
-import { type Dirent, readdirSync, readFileSync } from "node:fs";
+import { globSync, readFileSync } from "node:fs";
 import { extname, join } from "node:path";
 import { parseSync, Visitor } from "vite";
 
@@ -13,8 +13,6 @@ type SourceLanguage = NonNullable<ParserOptions["lang"]>;
 type ParsedModule = ParseResult["module"];
 
 const SOURCE_LANGUAGES: Map<string, SourceLanguage> = new Map([
-    [".cjs", "jsx"],
-    [".cts", "ts"],
     [".js", "jsx"],
     [".jsx", "jsx"],
     [".mjs", "jsx"],
@@ -23,60 +21,26 @@ const SOURCE_LANGUAGES: Map<string, SourceLanguage> = new Map([
     [".tsx", "tsx"],
 ]);
 
-const EXCLUDED_DIRECTORIES: Set<string> = new Set([
-    ".git",
-    ".gtkx",
-    "build",
-    "coverage",
-    "dist",
-    "node_modules",
-    "out-tsc",
-]);
-
 const sourceLanguage = (path: string): SourceLanguage | undefined => {
-    if (path.endsWith(".d.ts") || path.endsWith(".d.cts") || path.endsWith(".d.mts")) {
+    if (path.endsWith(".d.ts") || path.endsWith(".d.mts")) {
         return undefined;
     }
 
     return SOURCE_LANGUAGES.get(extname(path).toLowerCase());
 };
 
-const collectSourceEntry = (dir: string, entry: Dirent, found: string[]): void => {
-    const path = join(dir, entry.name);
-
-    if (entry.isDirectory()) {
-        if (!EXCLUDED_DIRECTORIES.has(entry.name)) {
-            sourceFilesIn(path, found);
-        }
-
-        return;
-    }
-
-    if (entry.isFile() && sourceLanguage(path) !== undefined) {
-        found.push(path);
-    }
-};
-
-const sourceFilesIn = (dir: string, found: string[]): void => {
-    let entries: Dirent[];
-
-    try {
-        entries = readdirSync(dir, { withFileTypes: true });
-    } catch {
-        return;
-    }
-
-    for (const entry of entries) {
-        collectSourceEntry(dir, entry, found);
-    }
-};
-
-const discoverSourceFiles = (dir: string): string[] => {
-    const files: string[] = [];
-    sourceFilesIn(dir, files);
-
-    return sortStringsBy(files, (path) => path);
-};
+const discoverSourceFiles = (dir: string): string[] =>
+    sortStringsBy(
+        globSync("**/{*,.*}", {
+            cwd: dir,
+            exclude: ["**/{build,coverage,dist,node_modules,out-tsc}/**"],
+            withFileTypes: true,
+        })
+            .filter((entry) => entry.isFile())
+            .map((entry) => join(entry.parentPath, entry.name))
+            .filter((path) => sourceLanguage(path) !== undefined),
+        (path) => path,
+    );
 
 const staticImportSources = (module: ParsedModule): string[] => [
     ...module.staticImports.map((statement) => statement.moduleRequest.value),

package/src/mcp/client-config.ts

@@ -0,0 +1,130 @@
+import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+
+type ClientName = "claude" | "cursor" | "vscode" | "opencode" | "codex";
+type ServerEntry = Record<string, unknown>;
+
+type Client = {
+    name: ClientName;
+    file: string;
+    key: string;
+    entry: ServerEntry;
+};
+
+type ClientResult =
+    | { kind: "written"; path: string; isCreated: boolean } |
+    { kind: "manual"; path: string; snippet: string };
+
+const SERVER_NAME = "gtkx";
+const COMMAND = "npx";
+const ARGS = ["gtkx", "mcp"];
+const CODEX_PATH = "~/.codex/config.toml";
+
+const CODEX_SNIPPET = [
+    `[mcp_servers.${SERVER_NAME}]`,
+    `command = ${JSON.stringify(COMMAND)}`,
+    `args = ${JSON.stringify(ARGS)}`,
+].join("\n");
+
+const CLIENTS: Client[] = [
+    {
+        name: "claude",
+        file: ".mcp.json",
+        key: "mcpServers",
+        entry: { command: COMMAND, args: ARGS },
+    },
+    {
+        name: "cursor",
+        file: join(".cursor", "mcp.json"),
+        key: "mcpServers",
+        entry: { command: COMMAND, args: ARGS },
+    },
+    {
+        name: "vscode",
+        file: join(".vscode", "mcp.json"),
+        key: "servers",
+        entry: { type: "stdio", command: COMMAND, args: ARGS },
+    },
+    {
+        name: "opencode",
+        file: "opencode.json",
+        key: "mcp",
+        entry: { type: "local", command: [COMMAND, ...ARGS], enabled: true },
+    },
+    {
+        name: "codex",
+        file: CODEX_PATH,
+        key: "mcp_servers",
+        entry: {},
+    },
+];
+
+const CLIENT_NAMES: Set<string> = new Set(CLIENTS.map((client) => client.name));
+
+const isClientName = (value: string): value is ClientName => CLIENT_NAMES.has(value);
+
+const isRecord = (value: unknown): value is Record<string, unknown> =>
+    typeof value === "object" && value !== null && !Array.isArray(value);
+
+const readOrUndefined = (path: string): string | undefined => {
+    try {
+        return readFileSync(path, "utf8");
+    } catch (error) {
+        if (error instanceof Error && (error as NodeJS.ErrnoException).code === "ENOENT") {
+            return undefined;
+        }
+
+        throw error;
+    }
+};
+
+const readJson = (path: string): Record<string, unknown> | undefined => {
+    const source = readOrUndefined(path);
+
+    if (source === undefined) {
+        return undefined;
+    }
+
+    const parsed: unknown = JSON.parse(source);
+
+    if (!isRecord(parsed)) {
+        throw new Error(`Refusing to edit ${path}: its contents are not a JSON object.`);
+    }
+
+    return parsed;
+};
+
+const getSection = (document: Record<string, unknown>, key: string): Record<string, unknown> => {
+    const section = document[key];
+
+    return isRecord(section) ? section : {};
+};
+
+const clientFor = (name: ClientName): Client => {
+    const client = CLIENTS.find((candidate) => candidate.name === name);
+
+    if (client === undefined) {
+        throw new Error(`Unknown MCP client "${name}".`);
+    }
+
+    return client;
+};
+
+const writeClientConfig = (root: string, name: ClientName): ClientResult => {
+    const client = clientFor(name);
+
+    if (name === "codex") {
+        return { kind: "manual", path: CODEX_PATH, snippet: CODEX_SNIPPET };
+    }
+
+    const path = join(root, client.file);
+    const existing = readJson(path);
+    const document = existing ?? {};
+    const section = { ...getSection(document, client.key), [SERVER_NAME]: client.entry };
+    mkdirSync(dirname(path), { recursive: true });
+    writeFileSync(path, `${JSON.stringify({ ...document, [client.key]: section }, null, 4)}\n`);
+
+    return { kind: "written", path, isCreated: existing === undefined };
+};
+
+export { CLIENTS, isClientName, writeClientConfig, type ClientName, type ClientResult };

package/src/settings/render.ts

@@ -9,7 +9,6 @@ type NamedSchema = {
 type EnvAssetDeclarations = {
     blocked: string[];
     icons: string[];
-    legacy: string[];
     resources: string[];
 };
 
@@ -209,15 +208,6 @@ const renderIconModule = (specifier: string): string => [
     "}",
 ].join("\n");
 
-const renderLegacyAssetModule = (specifier: string): string => [
-    `declare module ${toJsStringLiteral(specifier)} {`,
-    "    const resourceUri: string;",
-    "    const path: string;",
-    "    export { path };",
-    "    export default resourceUri;",
-    "}",
-].join("\n");
-
 const renderBlockedAssetModule = (specifier: string): string => [
     `declare module ${toJsStringLiteral(specifier)} {`,
     "    const assetImportRequiresResourceOrUrlQuery: {",
@@ -232,7 +222,7 @@ const renderEnvModule = (
     assetDeclarations?: EnvAssetDeclarations,
     options: EnvModuleOptions = {},
 ): string => {
-    const assets = assetDeclarations ?? { blocked: [], icons: [], legacy: [], resources: [] };
+    const assets = assetDeclarations ?? { blocked: [], icons: [], resources: [] };
     const usedNames: Set<string> = new Set();
 
     const schemas = files
@@ -241,7 +231,6 @@ const renderEnvModule = (
 
     const blocked = assets.blocked.map((specifier) => renderBlockedAssetModule(specifier));
     const icons = assets.icons.map((specifier) => renderIconModule(specifier));
-    const legacy = assets.legacy.map((specifier) => renderLegacyAssetModule(specifier));
     const resources = assets.resources.map((specifier) => renderResourceModule(specifier));
     const references = (options.references ?? []).map((path) => `/// <reference path=${JSON.stringify(path)} />`);
 
@@ -250,7 +239,6 @@ const renderEnvModule = (
         ...references,
         ...blocked,
         ...icons,
-        ...legacy,
         ...resources,
         ...schemas,
     ].join("\n\n")}\n`;

package/src/settings/schema.ts

@@ -1,25 +1,21 @@
-import { sortStrings, warn } from "@gtkx/utils";
+import { isPathInside, sortStrings, toPosixPath, warn } from "@gtkx/utils";
 import { createHash } from "node:crypto";
 import {
     copyFileSync,
-    type Dirent,
     existsSync,
     mkdirSync,
     mkdtempSync,
-    readdirSync,
     readFileSync,
     realpathSync,
     writeFileSync,
 } from "node:fs";
 import { tmpdir } from "node:os";
-import { basename, dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
+import { basename, dirname, join, relative, resolve } from "node:path";
 import { I18N_TYPES_FILENAME, i18nTypesPath } from "../i18n/types.js";
-import { DATA_IMPORT_PREFIX } from "../internal/data-dir.js";
 import { discoverSourceImports, type SourceImport } from "../internal/source-imports.js";
 import { removeTempDir } from "../internal/staging-dir.js";
 import {
     isBareRelativeAsset,
-    isDataAsset,
     parseIconSpecifier,
     parseResourceSpecifier,
 } from "../vite-plugins/asset-specifier.js";
@@ -57,27 +53,20 @@ const stageSchema = (dir: string, filePath: string): void => {
     copyFileSync(filePath, join(dir, stagedSchemaName(filePath)));
 };
 
-const toForwardSlashes = (value: string): string => value.replaceAll(/[/\\]/g, "/");
-
 const projectRelativeSchemaPath = (root: string, filePath: string): string | null => {
-    let rel: string;
+    let projectRoot: string;
+    let path: string;
 
     try {
-        rel = relative(realpathSync(root), realpathSync(filePath));
+        projectRoot = realpathSync(root);
+        path = realpathSync(filePath);
     } catch {
         return null;
     }
 
-    if (rel === "" || rel === ".." || rel.startsWith(`..${sep}`) || isAbsolute(rel)) {
-        return null;
-    }
-
-    return toForwardSlashes(rel);
+    return isPathInside(projectRoot, path) ? toPosixPath(relative(projectRoot, path)) : null;
 };
 
-const getModuleSpecifier = (dataDirAbs: string, filePath: string): string =>
-    `${DATA_IMPORT_PREFIX}/${toForwardSlashes(relative(dataDirAbs, filePath))}`;
-
 const getRelativeModuleSpecifier = (filePath: string): string => `*/${basename(filePath)}`;
 
 const sourceDirFor = (root: string): string => {
@@ -99,9 +88,6 @@ const findImportedSchemaFiles = (imports: SourceImport[]): string[] => {
     return sortStrings(new Set(files));
 };
 
-const legacyAssetSpecifier = (source: string): string | null =>
-    isDataAsset(source) ? source : null;
-
 const blockedAssetSpecifier = (source: string): string | null => {
     if (!isBareRelativeAsset(source)) {
         return null;
@@ -159,21 +145,15 @@ const iconModuleSpecifier = (source: string): string | null => {
 
 const findAssetModuleSpecifiers = (
     imports: SourceImport[],
-    isV2ResourceImports: boolean,
-): { blocked: string[]; icons: string[]; legacy: string[]; resources: string[] } => {
+): { blocked: string[]; icons: string[]; resources: string[] } => {
     const collect = (getSpecifier: (source: string) => string | null): string[] =>
         sortStrings(new Set(imports.map((entry) => getSpecifier(entry.source)).filter((value) => value !== null)));
 
-    if (isV2ResourceImports) {
-        return {
-            blocked: collect(blockedAssetSpecifier),
-            icons: collect(iconModuleSpecifier),
-            legacy: [],
-            resources: collect(resourceModuleSpecifier),
-        };
-    }
-
-    return { blocked: [], icons: [], legacy: collect(legacyAssetSpecifier), resources: [] };
+    return {
+        blocked: collect(blockedAssetSpecifier),
+        icons: collect(iconModuleSpecifier),
+        resources: collect(resourceModuleSpecifier),
+    };
 };
 
 const canonicalPath = (path: string): string => {
@@ -203,41 +183,10 @@ const assertUniqueSchemaBasenames = (schemaFiles: string[]): void => {
     }
 };
 
-const readVisibleEntries = (dir: string): Dirent[] => {
-    try {
-        return readdirSync(dir, { withFileTypes: true }).filter((entry) => !entry.name.startsWith("."));
-    } catch {
-        return [];
-    }
-};
-
-const isSchemaFile = (entry: Dirent): boolean => entry.isFile() && entry.name.endsWith(SCHEMA_SUFFIX);
-
-const collectSchemaFiles = (dir: string, found: string[]): void => {
-    for (const entry of readVisibleEntries(dir)) {
-        const full = join(dir, entry.name);
-
-        if (entry.isDirectory()) {
-            collectSchemaFiles(full, found);
-        } else if (isSchemaFile(entry)) {
-            found.push(full);
-        }
-    }
-};
-
-const findSchemaFiles = (dataDir: string): string[] => {
-    const found: string[] = [];
-    collectSchemaFiles(dataDir, found);
-
-    return sortStrings(found);
-};
-
-const stageAndCompileProjectSchemas = (root: string, dataDir: string | null): string | null => {
+const stageAndCompileProjectSchemas = (root: string): string | null => {
     const imports = discoverSourceImports(sourceDirFor(root));
-    const imported = findImportedSchemaFiles(imports);
-    assertUniqueSchemaBasenames(imported);
-    const legacy = dataDir === null ? [] : findSchemaFiles(join(root, dataDir));
-    const schemaFiles = sortStrings(new Set([...legacy, ...imported]));
+    const schemaFiles = findImportedSchemaFiles(imports);
+    assertUniqueSchemaBasenames(schemaFiles);
 
     if (schemaFiles.length === 0) {
         return null;
@@ -307,25 +256,14 @@ const didWriteChanges = (path: string, content: string): boolean => {
     return true;
 };
 
-const emitSchemaEnv = (
-    rootDir: string,
-    dataDir: string | null,
-    isV2ResourceImports = false,
-): SchemaEnvResult => {
-    const dataDirAbs = dataDir === null ? null : join(rootDir, dataDir);
-    const legacyFiles = dataDirAbs === null ? [] : findSchemaFiles(dataDirAbs);
+const emitSchemaEnv = (rootDir: string): SchemaEnvResult => {
     const imports = discoverSourceImports(sourceDirFor(rootDir));
-
-    const legacy = dataDirAbs === null
-        ? []
-        : parseProjectSchemas(legacyFiles, (filePath) => getModuleSpecifier(dataDirAbs, filePath));
-
     const importedFiles = findImportedSchemaFiles(imports);
     assertUniqueSchemaBasenames(importedFiles);
     const imported = parseProjectSchemas(importedFiles, getRelativeModuleSpecifier);
-    const assets = findAssetModuleSpecifiers(imports, isV2ResourceImports);
+    const assets = findAssetModuleSpecifiers(imports);
     const references = existsSync(i18nTypesPath(rootDir)) ? [`./${I18N_TYPES_FILENAME}`] : [];
-    const content = renderEnvModule([...legacy, ...imported], assets, { references });
+    const content = renderEnvModule(imported, assets, { references });
     const path = schemaEnvPath(rootDir);
     const isWritten = didWriteChanges(path, content);