@flyingrobots/graft 0.7.0 → 0.8.0

package/src/cli/init-model.ts

@@ -1,284 +0,0 @@
-export type JsonPrimitive = string | number | boolean | null;
-export type JsonArrayValue = JsonValue[];
-export type JsonValue = JsonPrimitive | JsonArrayValue | JsonObjectValue;
-
-export interface JsonObjectValue {
-  [key: string]: JsonValue | undefined;
-}
-
-type InitActionKind = "exists" | "create" | "append";
-export type GraftMcpRuntime = "repo-local" | "daemon";
-
-export class InitAction {
-  constructor(
-    readonly action: InitActionKind,
-    readonly label: string,
-    readonly detail?: string,
-  ) {}
-
-  static create(label: string, detail?: string): InitAction {
-    return new InitAction("create", label, detail);
-  }
-
-  static append(label: string, detail?: string): InitAction {
-    return new InitAction("append", label, detail);
-  }
-
-  static exists(label: string, detail?: string): InitAction {
-    return new InitAction("exists", label, detail);
-  }
-}
-
-export class InitFailure {
-  readonly ok = false;
-
-  constructor(
-    readonly cwd: string,
-    readonly error: string,
-  ) {}
-
-  toJSON(): JsonObjectValue {
-    return {
-      ok: this.ok,
-      cwd: this.cwd,
-      error: this.error,
-    };
-  }
-}
-
-function consumeFlag(args: string[], flag: string): boolean {
-  const index = args.indexOf(flag);
-  if (index === -1) {
-    return false;
-  }
-  args.splice(index, 1);
-  return true;
-}
-
-function consumeOption(args: string[], flag: string): string | undefined {
-  const index = args.indexOf(flag);
-  if (index === -1) {
-    return undefined;
-  }
-  if (index === args.length - 1) {
-    throw new Error(`Missing value for ${flag}`);
-  }
-  const [value] = args.splice(index, 2).slice(1);
-  return value;
-}
-
-function parseMcpRuntime(raw: string | undefined): { runtime: GraftMcpRuntime; explicit: boolean } {
-  if (raw === undefined) {
-    return { runtime: "repo-local", explicit: false };
-  }
-  if (raw === "repo-local" || raw === "daemon") {
-    return { runtime: raw, explicit: true };
-  }
-  throw new Error(`--mcp-runtime must be repo-local or daemon, got ${raw}`);
-}
-
-export class ParsedInitArgs {
-  constructor(
-    readonly json: boolean,
-    readonly mcpRuntime: GraftMcpRuntime,
-    readonly mcpRuntimeExplicit: boolean,
-    readonly writeClaudeMcp: boolean,
-    readonly writeClaudeHooks: boolean,
-    readonly writeTargetGitHooks: boolean,
-    readonly writeCodexMcp: boolean,
-    readonly writeCursorMcp: boolean,
-    readonly writeWindsurfMcp: boolean,
-    readonly writeContinueMcp: boolean,
-    readonly writeClineMcp: boolean,
-  ) {}
-
-  static parse(rawArgs: readonly string[]): ParsedInitArgs {
-    const args = [...rawArgs];
-    const runtime = parseMcpRuntime(consumeOption(args, "--mcp-runtime"));
-    const parsed = new ParsedInitArgs(
-      consumeFlag(args, "--json"),
-      runtime.runtime,
-      runtime.explicit,
-      consumeFlag(args, "--write-claude-mcp"),
-      consumeFlag(args, "--write-claude-hooks"),
-      consumeFlag(args, "--write-target-git-hooks"),
-      consumeFlag(args, "--write-codex-mcp"),
-      consumeFlag(args, "--write-cursor-mcp"),
-      consumeFlag(args, "--write-windsurf-mcp"),
-      consumeFlag(args, "--write-continue-mcp"),
-      consumeFlag(args, "--write-cline-mcp"),
-    );
-
-    if (args.length > 0) {
-      throw new Error(`Unknown init arguments: ${args.join(" ")}`);
-    }
-
-    return parsed;
-  }
-
-  get writesAnyMcpConfig(): boolean {
-    return this.writeClaudeMcp
-      || this.writeCodexMcp
-      || this.writeCursorMcp
-      || this.writeWindsurfMcp
-      || this.writeContinueMcp
-      || this.writeClineMcp;
-  }
-}
-
-export class GraftMcpServer {
-  readonly name = "graft";
-  readonly command = "npx";
-  readonly codexStartupTimeoutSec = 120;
-
-  constructor(readonly runtime: GraftMcpRuntime = "repo-local") {}
-
-  get args(): readonly string[] {
-    return this.runtime === "daemon"
-      ? ["-y", "@flyingrobots/graft", "serve", "--runtime", "daemon"]
-      : ["-y", "@flyingrobots/graft", "serve"];
-  }
-
-  toJsonServerEntry(): JsonObjectValue {
-    return {
-      command: this.command,
-      args: [...this.args],
-    };
-  }
-
-  toJsonMcpConfig(): JsonObjectValue {
-    return {
-      mcpServers: {
-        [this.name]: this.toJsonServerEntry(),
-      },
-    };
-  }
-
-  toContinueServerEntry(): JsonObjectValue {
-    return {
-      name: this.name,
-      command: this.command,
-      args: [...this.args],
-    };
-  }
-
-  toContinueConfig(): JsonObjectValue {
-    return {
-      mcpServers: [this.toContinueServerEntry()],
-    };
-  }
-
-  toCodexTomlBlock(): string {
-    return [
-      "[mcp_servers.graft]",
-      "command = \"npx\"",
-      this.toCodexTomlArgsLine(),
-      `startup_timeout_sec = ${String(this.codexStartupTimeoutSec)}`,
-      "",
-    ].join("\n");
-  }
-
-  toCodexTomlArgsLine(): string {
-    return `args = [${this.args.map((arg) => `"${arg}"`).join(", ")}]`;
-  }
-}
-
-export class GraftHookCommand {
-  constructor(readonly command: string) {}
-
-  toJsonValue(): JsonObjectValue {
-    return {
-      type: "command",
-      command: this.command,
-    };
-  }
-}
-
-export class GraftHookMatcher {
-  constructor(
-    readonly matcher: "Read",
-    readonly hooks: readonly GraftHookCommand[],
-  ) {}
-
-  toJsonValue(): JsonObjectValue {
-    return {
-      matcher: this.matcher,
-      hooks: this.hooks.map((hook) => hook.toJsonValue()),
-    };
-  }
-}
-
-export class GraftHooksConfig {
-  constructor(
-    readonly preToolUse: GraftHookMatcher,
-    readonly postToolUse: GraftHookMatcher,
-  ) {}
-
-  toJsonValue(): JsonObjectValue {
-    return {
-      hooks: {
-        PreToolUse: [this.preToolUse.toJsonValue()],
-        PostToolUse: [this.postToolUse.toJsonValue()],
-      },
-    };
-  }
-}
-
-export const GRAFT_MCP_SERVER = new GraftMcpServer();
-export const GRAFT_HOOKS_CONFIG = new GraftHooksConfig(
-  new GraftHookMatcher("Read", [
-    new GraftHookCommand("node --import tsx node_modules/@flyingrobots/graft/src/hooks/pretooluse-read.ts"),
-  ]),
-  new GraftHookMatcher("Read", [
-    new GraftHookCommand("node --import tsx node_modules/@flyingrobots/graft/src/hooks/posttooluse-read.ts"),
-  ]),
-);
-
-export class InitResult {
-  readonly ok = true;
-
-  constructor(
-    readonly cwd: string,
-    readonly actions: readonly InitAction[],
-    readonly hooksConfig: GraftHooksConfig,
-    readonly suggestedMcpServer: GraftMcpServer,
-  ) {}
-
-  toJSON(): JsonObjectValue {
-    return {
-      ok: this.ok,
-      cwd: this.cwd,
-      actions: this.actions.map((action) => ({
-        action: action.action,
-        label: action.label,
-        ...(action.detail !== undefined ? { detail: action.detail } : {}),
-      })),
-      hooksConfig: this.hooksConfig.toJsonValue(),
-      suggestedMcpServer: this.suggestedMcpServer.toJsonMcpConfig(),
-    };
-  }
-}
-
-export function isJsonObjectValue(value: unknown): value is JsonObjectValue {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-
-export function cloneJsonValue<T>(value: T): T {
-  return JSON.parse(JSON.stringify(value)) as T;
-}
-
-export function isGraftMcpServerEntryForRuntime(
-  value: JsonValue | undefined,
-  runtime: GraftMcpRuntime,
-): boolean {
-  if (!isJsonObjectValue(value)) {
-    return false;
-  }
-  const command = value["command"];
-  const args = value["args"];
-  const expected = new GraftMcpServer(runtime);
-  return command === expected.command
-    && Array.isArray(args)
-    && args.length === expected.args.length
-    && args.every((arg, index) => arg === expected.args[index]);
-}

package/src/cli/init-render.ts

@@ -1,54 +0,0 @@
-import { CanonicalJsonCodec } from "../adapters/canonical-json.js";
-import { attachCliSchemaMeta, validateCliOutput } from "../contracts/output-schemas.js";
-import { GRAFT_HOOKS_CONFIG, InitFailure, InitResult, ParsedInitArgs, type JsonObjectValue } from "./init-model.js";
-
-const codec = new CanonicalJsonCodec();
-
-interface Writer {
-  write(chunk: string): unknown;
-}
-
-function writeLine(writer: Writer, line = ""): void {
-  writer.write(`${line}\n`);
-}
-
-function indentJson(value: unknown, spaces = 2): string {
-  const json = JSON.stringify(value, null, spaces);
-  return json.split("\n").map((line) => `  ${line}`).join("\n");
-}
-
-export function renderInitText(result: InitResult, args: ParsedInitArgs, writer: Writer): void {
-  writeLine(writer);
-  writeLine(writer, `Initializing graft in ${result.cwd}`);
-  writeLine(writer);
-  for (const action of result.actions) {
-    const detail = action.detail !== undefined ? ` (${action.detail})` : "";
-    writeLine(writer, `  ${action.action.padEnd(6)} ${action.label}${detail}`);
-  }
-  writeLine(writer);
-
-  if (!args.writeClaudeHooks) {
-    writeLine(writer, "Add to .claude/settings.json for Claude Code hook integration:");
-    writeLine(writer);
-    writeLine(writer, JSON.stringify(GRAFT_HOOKS_CONFIG.toJsonValue(), null, 2));
-    writeLine(writer);
-  }
-
-  if (!args.writesAnyMcpConfig) {
-    writeLine(writer, "Done. Add graft to your MCP config:");
-    writeLine(writer);
-    writeLine(writer, indentJson(result.suggestedMcpServer.toJsonMcpConfig()));
-    writeLine(writer);
-    writeLine(writer, "Use explicit --write-*-mcp flags or --write-claude-hooks");
-    writeLine(writer, "or --write-target-git-hooks for one-step bootstrap into project-local config files.");
-  }
-
-  writeLine(writer);
-}
-
-export function emitInitJson(result: JsonObjectValue | InitFailure, writer: Writer): void {
-  const payload = result instanceof InitFailure
-    ? result.toJSON()
-    : result;
-  writer.write(`${codec.encode(validateCliOutput("init", attachCliSchemaMeta("init", payload)))}\n`);
-}

package/src/cli/init-target-hooks.ts

@@ -1,93 +0,0 @@
-import * as fs from "node:fs";
-import * as path from "node:path";
-import { execFileSync } from "node:child_process";
-import {
-  buildTargetGitHookScript,
-  isRecognizedTargetGitHook,
-  resolveGitHooksPath,
-  TARGET_GIT_TRANSITION_HOOKS,
-} from "../git/target-git-hook-bootstrap.js";
-import { InitAction } from "./init-model.js";
-
-function readGitValue(cwd: string, args: readonly string[]): string | null {
-  try {
-    const value = execFileSync("git", [...args], {
-      cwd,
-      encoding: "utf-8",
-      stdio: ["ignore", "pipe", "ignore"],
-    }).trim();
-    return value.length > 0 ? value : null;
-  } catch {
-    return null;
-  }
-}
-
-function relativeLabel(cwd: string, filePath: string): string {
-  const relative = path.relative(cwd, filePath);
-  if (relative.length === 0 || relative.startsWith("..")) {
-    return filePath;
-  }
-  return relative;
-}
-
-function resolveTargetGitHooksDirectory(cwd: string): {
-  configuredCoreHooksPath: string | null;
-  resolvedHooksPath: string;
-} {
-  const worktreeRoot = readGitValue(cwd, [
-    "rev-parse",
-    "--path-format=absolute",
-    "--show-toplevel",
-  ]);
-  const gitCommonDir = readGitValue(cwd, [
-    "rev-parse",
-    "--path-format=absolute",
-    "--git-common-dir",
-  ]);
-  if (worktreeRoot === null || gitCommonDir === null) {
-    throw new Error("--write-target-git-hooks requires a git worktree");
-  }
-
-  const configuredCoreHooksPath = readGitValue(cwd, ["config", "--get", "core.hooksPath"]);
-  return {
-    configuredCoreHooksPath,
-    resolvedHooksPath: resolveGitHooksPath(
-      worktreeRoot,
-      gitCommonDir,
-      configuredCoreHooksPath,
-    ),
-  };
-}
-
-export function ensureTargetGitHooks(cwd: string): InitAction[] {
-  const { resolvedHooksPath } = resolveTargetGitHooksDirectory(cwd);
-  const actions: InitAction[] = [];
-  fs.mkdirSync(resolvedHooksPath, { recursive: true });
-
-  for (const hookName of TARGET_GIT_TRANSITION_HOOKS) {
-    const hookPath = path.join(resolvedHooksPath, hookName);
-    const label = relativeLabel(cwd, hookPath);
-    const nextContent = buildTargetGitHookScript(hookName);
-    if (!fs.existsSync(hookPath)) {
-      fs.writeFileSync(hookPath, nextContent);
-      fs.chmodSync(hookPath, 0o755);
-      actions.push(InitAction.create(label, "wrote graft target git hook"));
-      continue;
-    }
-
-    const existing = fs.readFileSync(hookPath, "utf-8");
-    if (existing === nextContent) {
-      actions.push(InitAction.exists(label, "already has graft target git hook"));
-      continue;
-    }
-    if (isRecognizedTargetGitHook(existing, hookName)) {
-      fs.writeFileSync(hookPath, nextContent);
-      fs.chmodSync(hookPath, 0o755);
-      actions.push(InitAction.append(label, "updated graft target git hook"));
-      continue;
-    }
-    actions.push(InitAction.exists(label, "external hook preserved"));
-  }
-
-  return actions;
-}

package/src/cli/init.ts

@@ -1,124 +0,0 @@
-import * as path from "node:path";
-import { appendIfMissing, ensureTargetGitHooks, mergeClaudeHooksConfig, mergeClaudeMcpConfig, mergeClineMcpConfig, mergeCodexMcpConfig, mergeContinueMcpConfig, mergeCursorMcpConfig, mergeWindsurfMcpConfig, writeIfMissing } from "./init-bootstrap.js";
-import { writeCliError } from "./cli-error.js";
-import { GRAFT_HOOKS_CONFIG, GraftMcpServer, InitFailure, InitResult, ParsedInitArgs } from "./init-model.js";
-import { emitInitJson, renderInitText } from "./init-render.js";
-
-const GRAFTIGNORE_TEMPLATE = `# Graft ignore patterns — files matching these are refused by safe_read.
-# Syntax: same as .gitignore (glob matching via picomatch).
-
-# Examples:
-# *.generated.ts
-# vendor/**
-# data/**/*.json
-`;
-
-const READ_GUIDANCE_MARKER = "## File reads";
-
-const AGENT_SNIPPET = `## File reads
-
-This project uses [graft](https://github.com/flyingrobots/graft) as
-a context governor. Prefer graft's MCP tools over native file reads:
-
-- Use \`safe_read\` instead of \`Read\` for file contents
-- Use \`file_outline\` to see structure before reading
-- Use \`read_range\` with jump table entries for targeted reads
-- Use \`graft_diff\` instead of \`git diff\` for structural changes
-- Use \`explain\` if you get an unfamiliar reason code
-- Call \`set_budget\` at session start if context is tight
-
-These tools enforce read policy, cache observations, and track
-session metrics. Native reads bypass all of that.
-`;
-
-const GITIGNORE_ENTRY = "\n# Graft runtime data\n.graft/\n";
-
-interface Writer {
-  write(chunk: string): unknown;
-}
-
-export interface RunInitOptions {
-  cwd?: string | undefined;
-  args?: readonly string[] | undefined;
-  stdout?: Writer | undefined;
-  stderr?: Writer | undefined;
-}
-
-function initProject(cwd: string, args: ParsedInitArgs): InitResult {
-  const mcpServer = new GraftMcpServer(args.mcpRuntime);
-  const updateExistingMcp = args.mcpRuntimeExplicit;
-  const actions = [
-    writeIfMissing(path.join(cwd, ".graftignore"), GRAFTIGNORE_TEMPLATE, ".graftignore"),
-    appendIfMissing(path.join(cwd, ".gitignore"), ".graft/", GITIGNORE_ENTRY, ".gitignore"),
-    appendIfMissing(path.join(cwd, "CLAUDE.md"), READ_GUIDANCE_MARKER, `\n${AGENT_SNIPPET}`, "CLAUDE.md"),
-  ];
-
-  if (args.writeClaudeMcp) {
-    actions.push(mergeClaudeMcpConfig(cwd, mcpServer, updateExistingMcp));
-  }
-  if (args.writeClaudeHooks) {
-    actions.push(mergeClaudeHooksConfig(cwd));
-  }
-  if (args.writeTargetGitHooks) {
-    actions.push(...ensureTargetGitHooks(cwd));
-  }
-  if (args.writeCodexMcp) {
-    actions.push(mergeCodexMcpConfig(cwd, mcpServer, updateExistingMcp));
-    actions.push(
-      appendIfMissing(
-        path.join(cwd, "AGENTS.md"),
-        READ_GUIDANCE_MARKER,
-        `\n${AGENT_SNIPPET}`,
-        "AGENTS.md",
-      ),
-    );
-  }
-  if (args.writeCursorMcp) {
-    actions.push(mergeCursorMcpConfig(cwd, mcpServer, updateExistingMcp));
-  }
-  if (args.writeWindsurfMcp) {
-    actions.push(mergeWindsurfMcpConfig(cwd, mcpServer, updateExistingMcp));
-  }
-  if (args.writeContinueMcp) {
-    actions.push(mergeContinueMcpConfig(cwd, mcpServer, updateExistingMcp));
-  }
-  if (args.writeClineMcp) {
-    actions.push(mergeClineMcpConfig(cwd, mcpServer, updateExistingMcp));
-  }
-
-  return new InitResult(cwd, actions, GRAFT_HOOKS_CONFIG, mcpServer);
-}
-
-export function runInit(options: RunInitOptions = {}): void {
-  const cwd = options.cwd ?? process.cwd();
-  const args = options.args ?? process.argv.slice(3);
-  const stdout = options.stdout ?? process.stdout;
-  const stderr = options.stderr ?? process.stderr;
-
-  try {
-    const parsed = ParsedInitArgs.parse(args);
-    const result = initProject(cwd, parsed);
-    if (parsed.json) {
-      emitInitJson(result.toJSON(), stdout);
-      return;
-    }
-    renderInitText(result, parsed, stdout);
-  } catch (err: unknown) {
-    const message = err instanceof Error ? err.message : String(err);
-    process.exitCode = 1;
-    if (args.includes("--json")) {
-      emitInitJson(new InitFailure(cwd, message), stdout);
-      return;
-    }
-    writeCliError(stderr, message, {
-      usage:
-        "graft init [--json] [--mcp-runtime <repo-local|daemon>] [--write-claude-mcp] [--write-claude-hooks] "
-        + "[--write-target-git-hooks] [--write-codex-mcp] [--write-cursor-mcp] "
-        + "[--write-windsurf-mcp] [--write-continue-mcp] [--write-cline-mcp]",
-      nextSteps: [
-        "Use explicit --write-*-mcp flags to bootstrap project-local client config files.",
-        "Use --write-target-git-hooks only inside a git worktree.",
-      ],
-    });
-  }
-}

package/src/cli/json-document.ts

@@ -1,155 +0,0 @@
-import * as fs from "node:fs";
-import * as path from "node:path";
-import {
-  cloneJsonValue,
-  isJsonObjectValue,
-  type JsonArrayValue,
-  type JsonObjectValue,
-  type JsonValue,
-} from "./init-model.js";
-
-function formatJsonField(pointer: readonly string[]): string {
-  return pointer.length === 0 ? "document root" : pointer.join(".");
-}
-
-export class JsonArrayNode {
-  constructor(
-    private readonly value: JsonArrayValue,
-    private readonly label: string,
-    private readonly pointer: readonly string[] = [],
-  ) {}
-
-  static fromUnknown(
-    value: unknown,
-    label: string,
-    pointer: readonly string[] = [],
-  ): JsonArrayNode {
-    if (!Array.isArray(value)) {
-      throw new Error(`${label}: expected ${formatJsonField(pointer)} to be an array`);
-    }
-    return new JsonArrayNode(value as JsonArrayValue, label, pointer);
-  }
-
-  objectItems(): JsonObjectNode[] {
-    return this.value.map((item, index) =>
-      JsonObjectNode.fromUnknown(item, this.label, [...this.pointer, `[${String(index)}]`]),
-    );
-  }
-
-  objectEntries(): { index: number; node: JsonObjectNode }[] {
-    return this.value.map((item, index) => ({
-      index,
-      node: JsonObjectNode.fromUnknown(item, this.label, [...this.pointer, `[${String(index)}]`]),
-    }));
-  }
-
-  push(value: JsonValue): void {
-    this.value.push(cloneJsonValue(value));
-  }
-
-  set(index: number, value: JsonValue): void {
-    this.value[index] = cloneJsonValue(value);
-  }
-}
-
-export class JsonObjectNode {
-  constructor(
-    private readonly value: JsonObjectValue,
-    private readonly label: string,
-    private readonly pointer: readonly string[] = [],
-  ) {}
-
-  static fromUnknown(
-    value: unknown,
-    label: string,
-    pointer: readonly string[] = [],
-  ): JsonObjectNode {
-    if (!isJsonObjectValue(value)) {
-      throw new Error(`${label}: expected ${formatJsonField(pointer)} to be an object`);
-    }
-    return new JsonObjectNode(value, label, pointer);
-  }
-
-  has(key: string): boolean {
-    return this.value[key] !== undefined;
-  }
-
-  set(key: string, value: JsonValue): void {
-    this.value[key] = cloneJsonValue(value);
-  }
-
-  ensureObject(key: string): JsonObjectNode {
-    const current = this.value[key];
-    if (current === undefined) {
-      const created: JsonObjectValue = {};
-      this.value[key] = created;
-      return new JsonObjectNode(created, this.label, [...this.pointer, key]);
-    }
-    return JsonObjectNode.fromUnknown(current, this.label, [...this.pointer, key]);
-  }
-
-  ensureArray(key: string): JsonArrayNode {
-    const current = this.value[key];
-    if (current === undefined) {
-      const created: JsonArrayValue = [];
-      this.value[key] = created;
-      return new JsonArrayNode(created, this.label, [...this.pointer, key]);
-    }
-    return JsonArrayNode.fromUnknown(current, this.label, [...this.pointer, key]);
-  }
-
-  requireArray(key: string): JsonArrayNode {
-    const current = this.value[key];
-    if (current === undefined) {
-      throw new Error(`${this.label}: expected ${formatJsonField([...this.pointer, key])} to exist`);
-    }
-    return JsonArrayNode.fromUnknown(current, this.label, [...this.pointer, key]);
-  }
-
-  stringValue(key: string): string | undefined {
-    const current = this.value[key];
-    return typeof current === "string" ? current : undefined;
-  }
-
-  toJsonValue(): JsonObjectValue {
-    return this.value;
-  }
-}
-
-export class JsonObjectDocument {
-  constructor(
-    readonly label: string,
-    readonly filePath: string,
-    private readonly rootNode: JsonObjectNode,
-  ) {}
-
-  static create(
-    filePath: string,
-    label: string,
-    root: JsonObjectValue,
-  ): JsonObjectDocument {
-    return new JsonObjectDocument(
-      label,
-      filePath,
-      new JsonObjectNode(cloneJsonValue(root), label),
-    );
-  }
-
-  static open(filePath: string, label: string): JsonObjectDocument {
-    const parsed = JSON.parse(fs.readFileSync(filePath, "utf-8")) as unknown;
-    return new JsonObjectDocument(
-      label,
-      filePath,
-      JsonObjectNode.fromUnknown(parsed, label),
-    );
-  }
-
-  root(): JsonObjectNode {
-    return this.rootNode;
-  }
-
-  write(): void {
-    fs.mkdirSync(path.dirname(this.filePath), { recursive: true });
-    fs.writeFileSync(this.filePath, JSON.stringify(this.rootNode.toJsonValue(), null, 2));
-  }
-}