@zaip-ai/cli 6.3.0 → 7.5.0

package/templates/.agents/tools/repository-profile.mjs

@@ -0,0 +1,116 @@
+import { createHash, randomUUID } from "node:crypto";
+import { lstat, open, readFile, rename, rm, writeFile } from "node:fs/promises";
+import { resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { loadRepositoryPolicy, parseRepositoryPolicy } from "./repository-policy.mjs";
+
+const digest = (bytes) =>
+  bytes === null ? "missing" : createHash("sha256").update(bytes).digest("hex");
+const bytesAt = async (path) => {
+  try {
+    return await readFile(path);
+  } catch (error) {
+    if (error.code === "ENOENT") return null;
+    throw error;
+  }
+};
+
+/** Repository-owned setup. Preview is read-only; apply requires the exact preview baseline. */
+export async function configureRepository(root, argv) {
+  const [action, ...args] = argv;
+  if (!["show", "configure"].includes(action)) throw Error("Use show or configure");
+  const options = { write_paths: [], deny_paths: [] };
+  const seen = new Set();
+  for (let i = 0; i < args.length; i++) {
+    const flag = args[i];
+    if (flag === "--apply" && !seen.has(flag)) {
+      options.apply = true;
+      seen.add(flag);
+      continue;
+    }
+    if (
+      !["--profile", "--write-path", "--deny-path", "--expected-sha256"].includes(flag) ||
+      args[i + 1] === undefined
+    )
+      throw Error("Unknown or incomplete setup option");
+    const value = args[++i];
+    if (flag === "--write-path") options.write_paths.push(value);
+    else if (flag === "--deny-path") options.deny_paths.push(value);
+    else {
+      if (seen.has(flag)) throw Error("Duplicate setup option");
+      options[flag.slice(2)] = value;
+    }
+    seen.add(flag);
+  }
+  const project = await lstat(resolve(root, ".agents/config/project.yaml"));
+  if (!project.isFile() || project.isSymbolicLink()) throw Error("Installed project required");
+  const current = await loadRepositoryPolicy(root);
+  const path = resolve(root, ".agents/config/repository-policy.json");
+  const before = await bytesAt(path),
+    baseline = digest(before);
+  if (action === "show") {
+    if (args.length) throw Error("show takes no options");
+    return { configured: before !== null, sha256: baseline, policy: current };
+  }
+  if (!options.profile) throw Error("configure requires --profile");
+  const next = parseRepositoryPolicy({
+    ...current,
+    profile: options.profile,
+    ...(seen.has("--write-path")
+      ? { write_paths: options.write_paths }
+      : options.profile !== current.profile
+        ? { write_paths: [] }
+        : {}),
+    ...(seen.has("--deny-path") ? { deny_paths: options.deny_paths } : {}),
+  });
+  if (!options.apply) return { applied: false, expected_sha256: baseline, policy: next };
+  if (options["expected-sha256"] !== baseline)
+    throw Error("Policy changed or preview baseline missing; preview again");
+  const lockPath = path + ".lock",
+    temporary = path + "." + randomUUID() + ".tmp";
+  const lock = await open(lockPath, "wx", 0o600);
+  try {
+    await loadRepositoryPolicy(root);
+    if (digest(await bytesAt(path)) !== baseline)
+      throw Error("Policy changed concurrently; preview again");
+    const bytes = JSON.stringify(next, null, 2) + "\n";
+    if (before?.toString("utf8") === bytes)
+      return { applied: false, unchanged: true, sha256: baseline, policy: next };
+    await writeFile(temporary, bytes, { flag: "wx", mode: 0o600 });
+    if (before !== null) {
+      const backup = path + "." + baseline + ".backup";
+      try {
+        await writeFile(backup, before, { flag: "wx", mode: 0o600 });
+      } catch (error) {
+        if (error.code !== "EEXIST" || digest(await readFile(backup)) !== baseline) throw error;
+      }
+    }
+    await loadRepositoryPolicy(root);
+    if (digest(await bytesAt(path)) !== baseline) throw Error("Policy changed before replacement");
+    await rename(temporary, path);
+    return {
+      applied: true,
+      sha256: digest(Buffer.from(bytes)),
+      policy: await loadRepositoryPolicy(root),
+    };
+  } finally {
+    await lock.close();
+    await rm(temporary, { force: true });
+    await rm(lockPath, { force: true });
+  }
+}
+
+if (process.argv[1] && resolve(process.argv[1]) === fileURLToPath(import.meta.url)) {
+  try {
+    console.log(
+      JSON.stringify(
+        await configureRepository(resolve(import.meta.dirname, "../.."), process.argv.slice(2)),
+        null,
+        2,
+      ),
+    );
+  } catch (error) {
+    console.error(error.message);
+    process.exitCode = 1;
+  }
+}

package/templates/.agents/tools/repository-profile.test.mjs

@@ -0,0 +1,67 @@
+import { strict as assert } from "node:assert";
+import { mkdir, mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { test } from "node:test";
+import { configureRepository } from "./repository-profile.mjs";
+
+test("setup previews, applies once, preserves choices and rejects stale/concurrent changes", async () => {
+  const root = await mkdtemp(join(tmpdir(), "zaip-repo-setup-"));
+  try {
+    await mkdir(join(root, ".agents/config"), { recursive: true });
+    await writeFile(join(root, ".agents/config/project.yaml"), "zaip:\n  enabled: true\n");
+    const args = ["configure", "--profile", "infra", "--write-path", "terraform/**"];
+    assert.equal((await configureRepository(root, ["show"])).policy.profile, "general");
+    const preview = await configureRepository(root, args);
+    assert.equal(preview.expected_sha256, "missing");
+    assert.equal((await configureRepository(root, ["show"])).configured, false);
+    await assert.rejects(configureRepository(root, [...args, "--apply"]), /baseline/);
+    const applied = await configureRepository(root, [
+      ...args,
+      "--apply",
+      "--expected-sha256",
+      "missing",
+    ]);
+    assert.equal(applied.applied, true);
+    await assert.rejects(
+      configureRepository(root, [...args, "--apply", "--expected-sha256", "missing"]),
+      /changed/,
+    );
+    const path = join(root, ".agents/config/repository-policy.json");
+    const policy = JSON.parse(await readFile(path, "utf8"));
+    policy.related_repositories = { backend: { reference: "org/backend", access: "read_only" } };
+    await writeFile(path, JSON.stringify(policy));
+    const update = ["configure", "--profile", "infra", "--deny-path", "terraform/private/**"];
+    const next = await configureRepository(root, update);
+    const result = await configureRepository(root, [
+      ...update,
+      "--apply",
+      "--expected-sha256",
+      next.expected_sha256,
+    ]);
+    assert.deepEqual(result.policy.related_repositories, policy.related_repositories);
+    assert.deepEqual(result.policy.write_paths, ["terraform/**"]);
+    assert.equal(
+      (await configureRepository(root, ["configure", "--profile", "backend"])).policy.write_paths
+        .length,
+      0,
+    );
+    await assert.rejects(
+      configureRepository(root, [
+        "configure",
+        "--profile",
+        "infra",
+        "--write-path",
+        "../backend/**",
+      ]),
+    );
+    await writeFile(path + ".lock", "other writer");
+    await assert.rejects(
+      configureRepository(root, [...args, "--apply", "--expected-sha256", result.sha256]),
+      /EEXIST/,
+    );
+    assert.equal(await readFile(path + ".lock", "utf8"), "other writer");
+  } finally {
+    await rm(root, { recursive: true, force: true });
+  }
+});

package/templates/.agents/tools/secret-inventory.mjs

@@ -0,0 +1,150 @@
+// Names and source locations only. Never open dotenv, key material or local state.
+import { lstat, readdir, readFile, realpath } from "node:fs/promises";
+import { basename, extname, relative, resolve } from "node:path";
+import { pathToFileURL } from "node:url";
+
+const ignored = new Set([
+  ".git",
+  ".agents",
+  ".codex",
+  ".claude",
+  ".local",
+  ".tmp",
+  ".temp",
+  "node_modules",
+  "dist",
+  "build",
+  "coverage",
+  ".next",
+  ".astro",
+  ".turbo",
+  "vendor",
+]);
+const extensions = new Set([
+  ".ts",
+  ".tsx",
+  ".js",
+  ".jsx",
+  ".mjs",
+  ".cjs",
+  ".py",
+  ".sh",
+  ".tf",
+  ".yaml",
+  ".yml",
+]);
+const patterns = [
+  /\b(?:process|import\.meta)\.env\.([A-Z][A-Z0-9_]{1,99})\b/g,
+  /\b(?:process|import\.meta)\.env\s*\[\s*['"]([A-Z][A-Z0-9_]{1,99})['"]\s*\]/g,
+  /\b(?:Deno\.env\.get|os\.getenv|getenv|(?:get|require|read)(?:Env|Environment)(?:Var|Variable)?)\s*\(\s*['"]([A-Z][A-Z0-9_]{1,99})['"]/g,
+  /\b(?:env|secrets)\.([A-Z][A-Z0-9_]{1,99})\b/g,
+];
+const shellInterpolation = /\$\{([A-Z][A-Z0-9_]{1,99})(?::[-?][^}]*)?\}/g;
+
+function category(path) {
+  if (
+    /(^|\/)(?:_?ref(?:erences?)?|referencias|legacy(?:-[a-z]+)?|archive|archives)(\/|$)/i.test(path)
+  )
+    return "reference";
+  if (/(?:^|\/)(?:tests?|__tests__|fixtures?|e2e)(?:\/|$)|[._](?:test|spec)\./i.test(path))
+    return "test";
+  if (path.startsWith(".github/")) return "ci";
+  if (/(?:^|\/)(?:scripts|tools)(?:\/|$)/.test(path)) return "tooling";
+  return "source";
+}
+
+export async function inventory(root) {
+  root = await realpath(root);
+  const found = new Map();
+  let files = 0,
+    skipped = 0;
+  async function walk(dir) {
+    for (const entry of await readdir(dir, { withFileTypes: true })) {
+      if (
+        ignored.has(entry.name) ||
+        (entry.name.startsWith(".") && entry.name !== ".github") ||
+        /(?:^|[._-])(?:credentials?|private[-_]?key)(?:[._-]|$)/i.test(entry.name) ||
+        /\.(pem|key|p12|pfx|sqlite|db|log)$/i.test(entry.name)
+      ) {
+        skipped++;
+        continue;
+      }
+      const full = resolve(dir, entry.name);
+      const stat = await lstat(full);
+      if (stat.isSymbolicLink()) {
+        skipped++;
+        continue;
+      }
+      if (entry.isDirectory()) {
+        await walk(full);
+        continue;
+      }
+      if (
+        !stat.isFile() ||
+        stat.nlink !== 1 ||
+        stat.size > 1048576 ||
+        !extensions.has(extname(full))
+      ) {
+        skipped++;
+        continue;
+      }
+      if ((await realpath(full)) !== full) throw new Error("Non-canonical source file");
+      const source = await readFile(full, "utf8");
+      files++;
+      const path = relative(root, full).replaceAll("\\", "/");
+      const expressions = [...patterns];
+      if ([".sh", ".yaml", ".yml", ".tf"].includes(extname(full)))
+        expressions.push(shellInterpolation);
+      // A local wrapper is only recognized when its body explicitly reads env.
+      for (const helper of source.matchAll(
+        /function\s+([a-zA-Z_$][\w$]*)\s*\([^)]*\)[^{]*\{([^}]{0,1000})\}/g,
+      )) {
+        if (/\b(?:process\.env\[|Deno\.env\.get\(|import\.meta\.env\[)/.test(helper[2])) {
+          const escaped = helper[1].replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+          expressions.push(
+            new RegExp("\\b" + escaped + "\\s*\\(\\s*['\"]([A-Z][A-Z0-9_]{1,99})['\"]", "g"),
+          );
+        }
+      }
+      for (const expression of expressions) {
+        expression.lastIndex = 0;
+        for (const match of source.matchAll(expression)) {
+          const name = match[1];
+          const line = 1 + source.slice(0, match.index).split("\n").length - 1;
+          const location = { path, line, category: category(path) };
+          if (!found.has(name)) found.set(name, []);
+          if (!found.get(name).some((x) => x.path === path && x.line === line))
+            found.get(name).push(location);
+        }
+      }
+    }
+  }
+  await walk(root);
+  return {
+    schemaVersion: 1,
+    repository: basename(root),
+    scannedFiles: files,
+    skippedEntries: skipped,
+    limitations: [
+      "Static literal references only; dynamic environment keys require manual review.",
+      "No dotenv, key files, local state, dependencies or framework files are read.",
+    ],
+    variables: [...found]
+      .sort(([a], [b]) => a.localeCompare(b))
+      .map(([name, sources]) => ({ name, sources })),
+  };
+}
+
+if (process.argv[1] && import.meta.url === pathToFileURL(resolve(process.argv[1])).href) {
+  if (process.argv.length !== 2)
+    throw new Error("No arguments accepted; run in the selected repository");
+  const result = await inventory(process.cwd());
+  result.variables = result.variables.map(({ name, sources }) => ({
+    name,
+    occurrences: sources.length,
+    sources: ["source", "reference", "test", "ci", "tooling"].flatMap((category) =>
+      sources.filter((x) => x.category === category).slice(0, 2),
+    ),
+  }));
+  console.log(JSON.stringify(result));
+}

package/templates/.agents/tools/secret-inventory.test.mjs

@@ -0,0 +1,60 @@
+import assert from "node:assert/strict";
+import { link, mkdir, mkdtemp, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { test } from "node:test";
+import { inventory } from "./secret-inventory.mjs";
+
+test("reports names/locations only and excludes credential files and hardlinks", async () => {
+  const root = await mkdtemp(join(tmpdir(), "zaip-names-"));
+  try {
+    await writeFile(
+      join(root, "app.ts"),
+      'const a=process.env.API_KEY;\nconst b=Deno.env.get("DATABASE_URL");\nconst c=env.RUNTIME_SECRET; const inline="SENSITIVE_VALUE_CANARY";',
+    );
+    await writeFile(join(root, ".env"), "HIDDEN_NAME=SENSITIVE_VALUE_CANARY");
+    await mkdir(join(root, ".local"));
+    await writeFile(join(root, ".local", "hidden.ts"), "process.env.LOCAL_HIDDEN");
+    await mkdir(join(root, ".agents.backup-example"));
+    await writeFile(
+      join(root, ".agents.backup-example", "hidden.ts"),
+      "process.env.FRAMEWORK_HIDDEN",
+    );
+    await writeFile(join(root, "private.key"), "process.env.KEY_HIDDEN");
+    await mkdir(join(root, "_ref"));
+    await writeFile(join(root, "_ref", "old.ts"), "process.env.LEGACY_KEY");
+    await writeFile(join(root, "linked.ts"), "process.env.HARDLINK_HIDDEN");
+    await link(join(root, "linked.ts"), join(root, "linked-copy.ts"));
+    const result = await inventory(root);
+    assert.deepEqual(
+      result.variables.map((x) => x.name),
+      ["API_KEY", "DATABASE_URL", "LEGACY_KEY", "RUNTIME_SECRET"],
+    );
+    assert.equal(
+      result.variables.find((x) => x.name === "LEGACY_KEY").sources[0].category,
+      "reference",
+    );
+    assert.equal(JSON.stringify(result).includes("SENSITIVE_VALUE_CANARY"), false);
+    assert.equal(result.variables.find((x) => x.name === "DATABASE_URL").sources[0].line, 2);
+  } finally {
+    await rm(root, { recursive: true, force: true });
+  }
+});
+
+test("distinguishes JavaScript locals from shell interpolation and finds env wrappers", async () => {
+  const root = await mkdtemp(join(tmpdir(), "zaip-names-"));
+  try {
+    await writeFile(
+      join(root, "app.ts"),
+      'function required(name:string) { return process.env[name]; }\nrequired("VOICE_DATABASE_URL");\nconst text=`${LOCAL_CONSTANT}`;',
+    );
+    await writeFile(join(root, "compose.yaml"), "password: ${SERVICE_PASSWORD}");
+    const result = await inventory(root);
+    assert.deepEqual(
+      result.variables.map((x) => x.name),
+      ["SERVICE_PASSWORD", "VOICE_DATABASE_URL"],
+    );
+  } finally {
+    await rm(root, { recursive: true, force: true });
+  }
+});

package/templates/.agents/tools/visual-intake/cli.mjs

@@ -0,0 +1,72 @@
+import { realpath } from "node:fs/promises";
+import { readBytes } from "./fs.mjs";
+import { runIntake } from "./runtime.mjs";
+
+const [command, ...arguments_] = process.argv.slice(2);
+const options = {};
+try {
+  if (
+    !["create", "batch", "correct", "finish", "reopen", "read", "report", "recover"].includes(
+      command,
+    )
+  )
+    throw new Error("Expected create|batch|correct|finish|reopen|read|report|recover");
+  for (let index = 0; index < arguments_.length; index += 2) {
+    const name = arguments_[index];
+    const value = arguments_[index + 1];
+    if (
+      !["--workspace", "--conversation", "--session", "--input", "--test-fault"].includes(name) ||
+      !value ||
+      Object.hasOwn(options, name)
+    )
+      throw new Error("Invalid or duplicate intake option");
+    options[name] = value;
+  }
+  for (const required of ["--workspace", "--conversation", "--session"])
+    if (!options[required])
+      throw new Error("Workspace, conversation and session are explicit required inputs");
+  // biome-ignore lint/suspicious/noUndeclaredEnvVars: Standalone consumer fixture is not a cached Turbo task.
+  const testMode = process.env.VISUAL_INTAKE_TEST_MODE === "1";
+  // biome-ignore lint/suspicious/noUndeclaredEnvVars: Standalone consumer fixture is not a cached Turbo task.
+  const testHold = process.env.VISUAL_INTAKE_TEST_HOLD;
+  const checkpoints = [
+    "claim-before-json",
+    "claim-reclaim-observed",
+    "claim-acquired",
+    "before-stage",
+    "after-stage",
+    "after-journal",
+    "before-manifest",
+    "after-manifest",
+    "before-receipt",
+    "after-receipt",
+    "after-finalizing",
+  ];
+  if (options["--test-fault"] && (!testMode || !checkpoints.includes(options["--test-fault"])))
+    throw new Error("Fault injection requires explicit test mode and known checkpoint");
+  const workspace = await realpath(options["--workspace"]);
+  const request = options["--input"]
+    ? JSON.parse((await readBytes(workspace, options["--input"], 1024 * 1024)).toString("utf8"))
+    : null;
+  const checkpoint = async (name) => {
+    if (name === options["--test-fault"]) process.exit(86);
+    if (testMode && (testHold === name || (name === "claim-acquired" && testHold === "1"))) {
+      process.stderr.write(`INTAKE_TEST_HELD:${name}\n`);
+      await new Promise((resolve) => setTimeout(resolve, 1500));
+    }
+  };
+  const result = await runIntake({
+    workspace,
+    conversation: options["--conversation"],
+    session: options["--session"],
+    command,
+    request,
+    checkpoint,
+  });
+  process.stdout.write(`${JSON.stringify({ ok: true, ...result })}\n`);
+} catch (error) {
+  process.stdout.write(
+    `${JSON.stringify({ ok: false, error: error.code ? `Intake I/O error: ${error.code}` : error.message })}\n`,
+  );
+  process.exitCode = 1;
+}

package/templates/.agents/tools/visual-intake/fs.mjs

@@ -0,0 +1,137 @@
+import { createHash, randomUUID } from "node:crypto";
+import { constants } from "node:fs";
+import { lstat, mkdir, open, realpath, rename, unlink } from "node:fs/promises";
+import { dirname, isAbsolute, relative, resolve } from "node:path";
+
+export const encode = (value) => Buffer.from(`${JSON.stringify(sort(value))}\n`);
+function sort(value) {
+  if (Array.isArray(value)) return value.map(sort);
+  if (value && typeof value === "object")
+    return Object.fromEntries(
+      Object.keys(value)
+        .sort()
+        .map((key) => [key, sort(value[key])]),
+    );
+  return value;
+}
+export const digest = (bytes) => createHash("sha256").update(bytes).digest("hex");
+export const digestJson = (value) => digest(encode(value));
+export function identifier(value) {
+  if (
+    typeof value !== "string" ||
+    !/^[a-zA-Z0-9][a-zA-Z0-9_-]{0,63}$/.test(value) ||
+    /^(?:con|prn|aux|nul|com[1-9]|lpt[1-9])$/i.test(value)
+  )
+    throw new Error("Invalid portable identifier");
+  return value;
+}
+export function localPath(value) {
+  if (
+    typeof value !== "string" ||
+    !value ||
+    value.length > 220 ||
+    isAbsolute(value) ||
+    /[\\:<>"|?*]/.test(value) ||
+    [...value].some((character) => character.charCodeAt(0) < 32)
+  )
+    throw new Error("Expected safe relative local path");
+  const parts = value.split("/");
+  if (
+    parts.some(
+      (part) =>
+        !part ||
+        part === "." ||
+        part === ".." ||
+        /[. ]$/.test(part) ||
+        /^(?:con|prn|aux|nul|com[1-9]|lpt[1-9])(?:\.|$)/i.test(part),
+    )
+  )
+    throw new Error("Unsafe local path segment");
+  return value;
+}
+export async function safePath(root, name, parents = false) {
+  const parts = localPath(name).split("/");
+  let current = root;
+  for (const [index, part] of parts.entries()) {
+    current = resolve(current, part);
+    let metadata = await lstat(current).catch((error) => {
+      if (error.code === "ENOENT") return null;
+      throw error;
+    });
+    if (!metadata && parents && index < parts.length - 1) {
+      await mkdir(current).catch((error) => {
+        if (error.code !== "EEXIST") throw error;
+      });
+      metadata = await lstat(current);
+    }
+    if (metadata?.isSymbolicLink())
+      throw new Error("Symlink/reparse path is not an intake boundary");
+    if (metadata && index < parts.length - 1 && !metadata.isDirectory())
+      throw new Error("Intake parent must be a directory");
+    if (metadata && index === parts.length - 1 && !metadata.isFile() && !metadata.isDirectory())
+      throw new Error("Unsupported intake file type");
+  }
+  const offset = relative(root, current);
+  if (!offset || offset.startsWith("..") || isAbsolute(offset))
+    throw new Error("Path leaves intake boundary");
+  return current;
+}
+export async function directory(root, name) {
+  const path = await safePath(root, `${name}/_placeholder`, true);
+  return dirname(path);
+}
+export async function readBytes(root, name, limit = 8 * 1024 * 1024) {
+  const path = await safePath(root, name);
+  const handle = await open(path, constants.O_RDONLY | (constants.O_NOFOLLOW ?? 0));
+  try {
+    const metadata = await handle.stat();
+    if (!metadata.isFile() || metadata.size > limit)
+      throw new Error("Intake file is not regular or exceeds the byte limit");
+    const actual = await realpath(path);
+    const offset = relative(root, actual);
+    if (offset.startsWith("..") || isAbsolute(offset))
+      throw new Error("Read resolves outside intake boundary");
+    const bytes = await handle.readFile();
+    if (bytes.length > limit) throw new Error("Intake file exceeds the byte limit");
+    return bytes;
+  } finally {
+    await handle.close();
+  }
+}
+export async function optionalBytes(root, name, limit) {
+  try {
+    return await readBytes(root, name, limit);
+  } catch (error) {
+    if (error.code === "ENOENT") return null;
+    throw error;
+  }
+}
+export async function readJson(root, name) {
+  return JSON.parse((await readBytes(root, name, 32 * 1024 * 1024)).toString("utf8"));
+}
+export async function optionalJson(root, name) {
+  const bytes = await optionalBytes(root, name, 32 * 1024 * 1024);
+  return bytes === null ? null : JSON.parse(bytes.toString("utf8"));
+}
+export async function atomicWrite(root, name, bytes, exclusive = false) {
+  const path = await safePath(root, name, true);
+  const previous = await optionalBytes(root, name, 32 * 1024 * 1024);
+  if (exclusive && previous !== null) {
+    if (!previous.equals(bytes))
+      throw new Error("Immutable intake file already has different content");
+    return;
+  }
+  const temporary = resolve(dirname(path), `_write-${randomUUID()}.tmp`);
+  const handle = await open(temporary, "wx", 0o600);
+  try {
+    await handle.writeFile(bytes);
+    await handle.sync();
+  } finally {
+    await handle.close();
+  }
+  await safePath(root, name);
+  await rename(temporary, path);
+}
+export async function removeFile(root, name) {
+  await unlink(await safePath(root, name));
+}