claudeup 4.16.0 → 4.18.0

package/src/services/alias-store.js

@@ -0,0 +1,77 @@
+/**
+ * In-memory types and defaults for the managed `claude` alias.
+ *
+ * Persistence has moved:
+ *   - Alias name lives in Claude Code's `settings.json` under `claudeup.aliasName`
+ *     (read/written via `alias-settings.ts`).
+ *   - Flag values are read from the user's shell rc file on screen mount
+ *     (via `parseAliasFromRc` in `alias-shell-writer.ts`). Edits stay in
+ *     memory until the user presses `w` to write the rc file.
+ *
+ * This module is filesystem-free so it can be imported by tests and pure
+ * logic without dragging in `claude-settings.ts`'s module-level `os.homedir()`
+ * constants.
+ */
+import { ALIAS_FLAGS } from "../data/alias-flags.js";
+/** Default alias name. POSIX/fish-safe, short, and not in conflict with `claude`. */
+export const DEFAULT_ALIAS_NAME = "c";
+/**
+ * Validate a candidate alias name. Returns null when valid, or a human
+ * reason when invalid.
+ *
+ * We refuse anything that isn't `[A-Za-z_][A-Za-z0-9_-]*` — that's the
+ * intersection of POSIX `name` rules and fish's `alias NAME …` accepting
+ * set, and avoids the need to quote the name on either side of the `=`.
+ */
+export function validateAliasName(name) {
+    if (name.length === 0)
+        return "Alias name cannot be empty.";
+    if (name.length > 32)
+        return "Alias name is unreasonably long (>32 chars).";
+    if (!/^[A-Za-z_][A-Za-z0-9_-]*$/.test(name)) {
+        return "Alias name must start with a letter or underscore and contain only letters, digits, _ or -.";
+    }
+    return null;
+}
+/**
+ * Build the default in-memory config. Used when no managed block exists in
+ * the rc file (every flag disabled, default alias name).
+ */
+export function defaultAliasConfig() {
+    const flags = {};
+    for (const flag of ALIAS_FLAGS) {
+        flags[flag.id] = defaultValueFor(flag);
+    }
+    return { aliasName: DEFAULT_ALIAS_NAME, flags };
+}
+export function defaultValueFor(flag) {
+    switch (flag.kind) {
+        case "boolean":
+            return { kind: "boolean", enabled: false };
+        case "tri-state":
+            return { kind: "tri-state", state: "unset" };
+        case "select":
+            return {
+                kind: "select",
+                enabled: false,
+                value: flag.options?.[0]?.value ?? "",
+            };
+        case "text":
+            return { kind: "text", enabled: false, value: "" };
+        case "optional-text":
+            return { kind: "optional-text", enabled: false, value: "" };
+        case "text-list":
+            return {
+                kind: "text-list",
+                enabled: false,
+                values: [...(flag.defaultValues ?? [])],
+            };
+        case "multi-with-custom":
+            return {
+                kind: "multi-with-custom",
+                enabled: false,
+                picked: [],
+                custom: [...(flag.defaultValues ?? [])],
+            };
+    }
+}

package/src/services/alias-store.ts

@@ -0,0 +1,112 @@
+/**
+ * In-memory types and defaults for the managed `claude` alias.
+ *
+ * Persistence has moved:
+ *   - Alias name lives in Claude Code's `settings.json` under `claudeup.aliasName`
+ *     (read/written via `alias-settings.ts`).
+ *   - Flag values are read from the user's shell rc file on screen mount
+ *     (via `parseAliasFromRc` in `alias-shell-writer.ts`). Edits stay in
+ *     memory until the user presses `w` to write the rc file.
+ *
+ * This module is filesystem-free so it can be imported by tests and pure
+ * logic without dragging in `claude-settings.ts`'s module-level `os.homedir()`
+ * constants.
+ */
+
+import { ALIAS_FLAGS, type AliasFlag } from "../data/alias-flags.js";
+
+/**
+ * Per-flag value shapes. Discriminator is `kind`, mirroring `AliasFlag.kind`.
+ */
+export type FlagValue =
+  | { kind: "boolean"; enabled: boolean }
+  | { kind: "tri-state"; state: "unset" | "on" | "off" }
+  | { kind: "select"; enabled: boolean; value: string }
+  | { kind: "text"; enabled: boolean; value: string }
+  | { kind: "optional-text"; enabled: boolean; value: string }
+  | { kind: "text-list"; enabled: boolean; values: string[] }
+  | {
+      kind: "multi-with-custom";
+      enabled: boolean;
+      picked: string[];
+      custom: string[];
+    };
+
+/**
+ * In-memory alias configuration. No `version` field since this isn't
+ * persisted as-is anymore — the alias name is stored in `settings.json`
+ * and flag values come from the rc file.
+ */
+export interface AliasConfig {
+  /**
+   * Name of the shell alias. Default `"c"` so users can keep typing the
+   * vanilla `claude` command alongside the wrapped one.
+   */
+  aliasName: string;
+  /** Per-flag state, keyed by `AliasFlag.id`. */
+  flags: Record<string, FlagValue>;
+}
+
+/** Default alias name. POSIX/fish-safe, short, and not in conflict with `claude`. */
+export const DEFAULT_ALIAS_NAME = "c";
+
+/**
+ * Validate a candidate alias name. Returns null when valid, or a human
+ * reason when invalid.
+ *
+ * We refuse anything that isn't `[A-Za-z_][A-Za-z0-9_-]*` — that's the
+ * intersection of POSIX `name` rules and fish's `alias NAME …` accepting
+ * set, and avoids the need to quote the name on either side of the `=`.
+ */
+export function validateAliasName(name: string): string | null {
+  if (name.length === 0) return "Alias name cannot be empty.";
+  if (name.length > 32) return "Alias name is unreasonably long (>32 chars).";
+  if (!/^[A-Za-z_][A-Za-z0-9_-]*$/.test(name)) {
+    return "Alias name must start with a letter or underscore and contain only letters, digits, _ or -.";
+  }
+  return null;
+}
+
+/**
+ * Build the default in-memory config. Used when no managed block exists in
+ * the rc file (every flag disabled, default alias name).
+ */
+export function defaultAliasConfig(): AliasConfig {
+  const flags: Record<string, FlagValue> = {};
+  for (const flag of ALIAS_FLAGS) {
+    flags[flag.id] = defaultValueFor(flag);
+  }
+  return { aliasName: DEFAULT_ALIAS_NAME, flags };
+}
+
+export function defaultValueFor(flag: AliasFlag): FlagValue {
+  switch (flag.kind) {
+    case "boolean":
+      return { kind: "boolean", enabled: false };
+    case "tri-state":
+      return { kind: "tri-state", state: "unset" };
+    case "select":
+      return {
+        kind: "select",
+        enabled: false,
+        value: flag.options?.[0]?.value ?? "",
+      };
+    case "text":
+      return { kind: "text", enabled: false, value: "" };
+    case "optional-text":
+      return { kind: "optional-text", enabled: false, value: "" };
+    case "text-list":
+      return {
+        kind: "text-list",
+        enabled: false,
+        values: [...(flag.defaultValues ?? [])],
+      };
+    case "multi-with-custom":
+      return {
+        kind: "multi-with-custom",
+        enabled: false,
+        picked: [],
+        custom: [...(flag.defaultValues ?? [])],
+      };
+  }
+}

package/src/services/gitignore-fixer.js

@@ -6,8 +6,9 @@
  *     because patterns are already present).
  *
  *   - `applyDestructiveFix`: index-mutating — runs `git rm --cached <path>`
- *     for tracked-but-should-ignore, `git add <path>` (after stripping
- *     gitignore lines) for ignored-but-should-track / untracked-and-should-track.
+ *     for tracked-but-should-ignore, `git add <path>` (after making sure
+ *     gitignore has any needed `!` exceptions) for ignored-but-should-track /
+ *     untracked-and-should-track.
  *     Each call handles ONE violation; the caller is responsible for confirming
  *     each one with the user.
  *
@@ -17,6 +18,7 @@ import { readFile, writeFile, appendFile } from "node:fs/promises";
 import { existsSync } from "node:fs";
 import { join } from "node:path";
 import { spawn } from "node:child_process";
+import { getGitignoreRuleReason } from "../data/gitignore-reasons.js";
 const CLAUDEUP_HEADER = "# Added by claudeup";
 export async function applySafeFixes(cwd, violations) {
     const safe = violations.filter((v) => v.severity === "safe" && v.kind === "missing-from-gitignore");
@@ -44,7 +46,7 @@ export async function applySafeFixes(cwd, violations) {
     const block = [
         "",
         CLAUDEUP_HEADER,
-        ...appended,
+        ...appended.flatMap(formatGitignoreEntry),
         "",
     ].join("\n");
     if (existing.length > 0 && !existing.endsWith("\n")) {
@@ -55,19 +57,26 @@ export async function applySafeFixes(cwd, violations) {
     }
     return { appended, alreadyPresent };
 }
-export async function applyDestructiveFix(cwd, violation) {
+export async function applyDestructiveFix(cwd, violation, rulePattern = violation.path) {
     switch (violation.kind) {
         case "tracked-but-should-ignore": {
             await runGit(["rm", "--cached", "--", violation.path], cwd);
             // Then make sure .gitignore has the entry so it stays out
-            await appendIfMissing(cwd, violation.path);
+            await appendIfMissing(cwd, rulePattern);
             return {
                 applied: true,
-                message: `Removed ${violation.path} from index and added to .gitignore`,
+                message: `Removed ${violation.path} from index and added ${rulePattern} to .gitignore`,
             };
         }
         case "ignored-but-should-track": {
             await stripGitignoreLine(cwd, violation.path);
+            await appendTrackExceptionsIfNeeded(cwd, violation.path);
+            if (!existsSync(join(cwd, violation.path))) {
+                return {
+                    applied: true,
+                    message: `Made ${violation.path} trackable; file does not exist yet`,
+                };
+            }
             try {
                 await runGit(["add", "--", violation.path], cwd);
             }
@@ -83,13 +92,14 @@ export async function applyDestructiveFix(cwd, violation) {
             };
         }
         case "untracked-and-should-track": {
+            await appendTrackExceptionsIfNeeded(cwd, violation.path);
             await runGit(["add", "--", violation.path], cwd);
             return { applied: true, message: `Staged ${violation.path}` };
         }
         case "missing-from-gitignore": {
             // Treat as a safe append for symmetry — caller can route through here too.
-            await appendIfMissing(cwd, violation.path);
-            return { applied: true, message: `Added ${violation.path} to .gitignore` };
+            await appendIfMissing(cwd, rulePattern);
+            return { applied: true, message: `Added ${rulePattern} to .gitignore` };
         }
     }
 }
@@ -127,10 +137,49 @@ async function appendIfMissing(cwd, pattern) {
     const lines = existing.split("\n").map((l) => l.trim());
     if (lines.includes(pattern))
         return;
-    const block = (existing.length > 0 && !existing.endsWith("\n") ? "\n" : "") +
-        `${CLAUDEUP_HEADER}\n${pattern}\n`;
+    // Only emit the "# Added by claudeup" header once — when fixing several
+    // entries in one pass (F), the file already has the header from the first.
+    const needsHeader = !lines.includes(CLAUDEUP_HEADER);
+    const prefix = existing.length > 0 && !existing.endsWith("\n") ? "\n" : "";
+    const header = needsHeader ? `${CLAUDEUP_HEADER}\n` : "";
+    const block = `${prefix}${header}${formatGitignoreEntry(pattern).join("\n")}\n`;
     await appendFile(gitignorePath, block);
 }
+function formatGitignoreEntry(pattern) {
+    return [`# ${getGitignoreRuleReason("ignore", pattern)}`, pattern];
+}
+async function appendTrackExceptionsIfNeeded(cwd, path) {
+    if (!(await pathIsIgnored(cwd, path)))
+        return;
+    const gitignorePath = join(cwd, ".gitignore");
+    const existing = existsSync(gitignorePath)
+        ? await readFile(gitignorePath, "utf8")
+        : "";
+    const lines = new Set(existing.split("\n").map((line) => line.trim()).filter(Boolean));
+    const additions = unignorePatternsForPath(path).filter((line) => !lines.has(line));
+    if (additions.length === 0)
+        return;
+    const block = [
+        existing.length > 0 && !existing.endsWith("\n") ? "\n" : "",
+        CLAUDEUP_HEADER,
+        `# ${getGitignoreRuleReason("track", path)}`,
+        ...additions,
+        "",
+    ].join("\n");
+    await appendFile(gitignorePath, block);
+}
+function unignorePatternsForPath(path) {
+    const normalized = path.replace(/^\/+/, "").replace(/\/+$/, "");
+    if (!normalized)
+        return [];
+    const parts = normalized.split("/");
+    const patterns = [];
+    for (let i = 0; i < parts.length - 1; i++) {
+        patterns.push(`!/${parts.slice(0, i + 1).join("/")}/`);
+    }
+    patterns.push(`!/${normalized}`);
+    return patterns;
+}
 async function stripGitignoreLine(cwd, pattern) {
     const gitignorePath = join(cwd, ".gitignore");
     if (!existsSync(gitignorePath))
@@ -144,6 +193,17 @@ async function stripGitignoreLine(cwd, pattern) {
         await writeFile(gitignorePath, filtered);
     }
 }
+async function pathIsIgnored(cwd, path) {
+    try {
+        await runGit(["check-ignore", "--quiet", "--", path], cwd);
+        return true;
+    }
+    catch (err) {
+        if (err instanceof GitError && err.code === 1)
+            return false;
+        return false;
+    }
+}
 class GitError extends Error {
     code;
     stderr;

package/src/services/gitignore-fixer.ts

@@ -6,8 +6,9 @@
  *     because patterns are already present).
  *
  *   - `applyDestructiveFix`: index-mutating — runs `git rm --cached <path>`
- *     for tracked-but-should-ignore, `git add <path>` (after stripping
- *     gitignore lines) for ignored-but-should-track / untracked-and-should-track.
+ *     for tracked-but-should-ignore, `git add <path>` (after making sure
+ *     gitignore has any needed `!` exceptions) for ignored-but-should-track /
+ *     untracked-and-should-track.
  *     Each call handles ONE violation; the caller is responsible for confirming
  *     each one with the user.
  *
@@ -18,6 +19,7 @@ import { readFile, writeFile, appendFile } from "node:fs/promises";
 import { existsSync } from "node:fs";
 import { join } from "node:path";
 import { spawn } from "node:child_process";
+import { getGitignoreRuleReason } from "../data/gitignore-reasons.js";
 import type { Violation } from "../types/gitignore.js";
 
 const CLAUDEUP_HEADER = "# Added by claudeup";
@@ -62,7 +64,7 @@ export async function applySafeFixes(
   const block = [
     "",
     CLAUDEUP_HEADER,
-    ...appended,
+    ...appended.flatMap(formatGitignoreEntry),
     "",
   ].join("\n");
 
@@ -83,19 +85,27 @@ export interface DestructiveFixResult {
 export async function applyDestructiveFix(
   cwd: string,
   violation: Violation,
+  rulePattern = violation.path,
 ): Promise<DestructiveFixResult> {
   switch (violation.kind) {
     case "tracked-but-should-ignore": {
       await runGit(["rm", "--cached", "--", violation.path], cwd);
       // Then make sure .gitignore has the entry so it stays out
-      await appendIfMissing(cwd, violation.path);
+      await appendIfMissing(cwd, rulePattern);
       return {
         applied: true,
-        message: `Removed ${violation.path} from index and added to .gitignore`,
+        message: `Removed ${violation.path} from index and added ${rulePattern} to .gitignore`,
       };
     }
     case "ignored-but-should-track": {
       await stripGitignoreLine(cwd, violation.path);
+      await appendTrackExceptionsIfNeeded(cwd, violation.path);
+      if (!existsSync(join(cwd, violation.path))) {
+        return {
+          applied: true,
+          message: `Made ${violation.path} trackable; file does not exist yet`,
+        };
+      }
       try {
         await runGit(["add", "--", violation.path], cwd);
       } catch (err) {
@@ -112,13 +122,14 @@ export async function applyDestructiveFix(
       };
     }
     case "untracked-and-should-track": {
+      await appendTrackExceptionsIfNeeded(cwd, violation.path);
       await runGit(["add", "--", violation.path], cwd);
       return { applied: true, message: `Staged ${violation.path}` };
     }
     case "missing-from-gitignore": {
       // Treat as a safe append for symmetry — caller can route through here too.
-      await appendIfMissing(cwd, violation.path);
-      return { applied: true, message: `Added ${violation.path} to .gitignore` };
+      await appendIfMissing(cwd, rulePattern);
+      return { applied: true, message: `Added ${rulePattern} to .gitignore` };
     }
   }
 }
@@ -158,11 +169,57 @@ async function appendIfMissing(cwd: string, pattern: string): Promise<void> {
     : "";
   const lines = existing.split("\n").map((l) => l.trim());
   if (lines.includes(pattern)) return;
-  const block = (existing.length > 0 && !existing.endsWith("\n") ? "\n" : "") +
-    `${CLAUDEUP_HEADER}\n${pattern}\n`;
+  // Only emit the "# Added by claudeup" header once — when fixing several
+  // entries in one pass (F), the file already has the header from the first.
+  const needsHeader = !lines.includes(CLAUDEUP_HEADER);
+  const prefix = existing.length > 0 && !existing.endsWith("\n") ? "\n" : "";
+  const header = needsHeader ? `${CLAUDEUP_HEADER}\n` : "";
+  const block = `${prefix}${header}${formatGitignoreEntry(pattern).join("\n")}\n`;
   await appendFile(gitignorePath, block);
 }
 
+function formatGitignoreEntry(pattern: string): string[] {
+  return [`# ${getGitignoreRuleReason("ignore", pattern)}`, pattern];
+}
+
+async function appendTrackExceptionsIfNeeded(
+  cwd: string,
+  path: string,
+): Promise<void> {
+  if (!(await pathIsIgnored(cwd, path))) return;
+
+  const gitignorePath = join(cwd, ".gitignore");
+  const existing = existsSync(gitignorePath)
+    ? await readFile(gitignorePath, "utf8")
+    : "";
+  const lines = new Set(
+    existing.split("\n").map((line) => line.trim()).filter(Boolean),
+  );
+  const additions = unignorePatternsForPath(path).filter((line) => !lines.has(line));
+  if (additions.length === 0) return;
+
+  const block = [
+    existing.length > 0 && !existing.endsWith("\n") ? "\n" : "",
+    CLAUDEUP_HEADER,
+    `# ${getGitignoreRuleReason("track", path)}`,
+    ...additions,
+    "",
+  ].join("\n");
+  await appendFile(gitignorePath, block);
+}
+
+function unignorePatternsForPath(path: string): string[] {
+  const normalized = path.replace(/^\/+/, "").replace(/\/+$/, "");
+  if (!normalized) return [];
+  const parts = normalized.split("/");
+  const patterns: string[] = [];
+  for (let i = 0; i < parts.length - 1; i++) {
+    patterns.push(`!/${parts.slice(0, i + 1).join("/")}/`);
+  }
+  patterns.push(`!/${normalized}`);
+  return patterns;
+}
+
 async function stripGitignoreLine(cwd: string, pattern: string): Promise<void> {
   const gitignorePath = join(cwd, ".gitignore");
   if (!existsSync(gitignorePath)) return;
@@ -176,6 +233,16 @@ async function stripGitignoreLine(cwd: string, pattern: string): Promise<void> {
   }
 }
 
+async function pathIsIgnored(cwd: string, path: string): Promise<boolean> {
+  try {
+    await runGit(["check-ignore", "--quiet", "--", path], cwd);
+    return true;
+  } catch (err) {
+    if (err instanceof GitError && err.code === 1) return false;
+    return false;
+  }
+}
+
 class GitError extends Error {
   constructor(public code: number, public stderr: string) {
     super(`git exited ${code}: ${stderr}`);

package/src/services/gitignore-prerun.js

@@ -4,7 +4,7 @@
  * Called from `prerunner/index.ts` (Step 0.9) on every claudeup invocation.
  * Resolves the manifest, runs detection, and prints a concise warning when
  * violations exist. Does NOT auto-apply fixes — the user must open the
- * Gitignore tab and confirm. This mirrors the plugin-version-mismatch flow
+ * Git State tab and confirm. This mirrors the plugin-version-mismatch flow
  * where prerun *warns* and the TUI provides the interactive fix dialog.
  */
 import { resolveGitignore } from "./gitignore-resolver.js";
@@ -34,10 +34,10 @@ export async function checkGitignore(cwd) {
 export function formatPrerunWarning(result) {
     if (result.violationCount === 0)
         return null;
-    return `⚠ ${result.violationCount} gitignore issue(s) detected. Run: claudeup → Gitignore tab to review and fix`;
+    return `⚠ ${result.violationCount} git state issue(s) detected. Run: claudeup → Git State tab to review and fix`;
 }
 /**
- * Verbose multi-line summary, used by the Gitignore tab when the user wants
+ * Verbose multi-line summary, used by the Git State tab when the user wants
  * to know what's wrong before deciding what to do.
  */
 export async function describeViolations(cwd, violations) {

package/src/services/gitignore-prerun.ts

@@ -4,7 +4,7 @@
  * Called from `prerunner/index.ts` (Step 0.9) on every claudeup invocation.
  * Resolves the manifest, runs detection, and prints a concise warning when
  * violations exist. Does NOT auto-apply fixes — the user must open the
- * Gitignore tab and confirm. This mirrors the plugin-version-mismatch flow
+ * Git State tab and confirm. This mirrors the plugin-version-mismatch flow
  * where prerun *warns* and the TUI provides the interactive fix dialog.
  */
 
@@ -43,11 +43,11 @@ export async function checkGitignore(cwd: string): Promise<PrerunResult> {
  */
 export function formatPrerunWarning(result: PrerunResult): string | null {
   if (result.violationCount === 0) return null;
-  return `⚠ ${result.violationCount} gitignore issue(s) detected. Run: claudeup → Gitignore tab to review and fix`;
+  return `⚠ ${result.violationCount} git state issue(s) detected. Run: claudeup → Git State tab to review and fix`;
 }
 
 /**
- * Verbose multi-line summary, used by the Gitignore tab when the user wants
+ * Verbose multi-line summary, used by the Git State tab when the user wants
  * to know what's wrong before deciding what to do.
  */
 export async function describeViolations(

package/src/services/gitignore-service.js

@@ -22,8 +22,26 @@ export async function loadGitignoreState(cwd) {
 export async function applyAllSafeFixes(cwd, violations) {
     return coreApplySafeFixes(cwd, violations);
 }
-export async function applyDestructiveFix(cwd, violation) {
-    return coreApplyDestructiveFix(cwd, violation);
+export async function applyDestructiveFix(cwd, violation, rulePattern) {
+    return coreApplyDestructiveFix(cwd, violation, rulePattern);
+}
+export async function ensureProjectManifestForEdit(cwd, resolved) {
+    const projectManifestPath = join(cwd, ".claude", "gitignore.json");
+    if (existsSync(projectManifestPath)) {
+        const existing = await readFile(projectManifestPath, "utf8");
+        if (existing.trim().length > 0)
+            return projectManifestPath;
+    }
+    const manifest = { ignore: [], track: [] };
+    for (const rule of resolved.rules) {
+        if (rule.action === "ignore")
+            manifest.ignore.push(rule.pattern);
+        else
+            manifest.track.push(rule.pattern);
+    }
+    await mkdir(dirname(projectManifestPath), { recursive: true });
+    await writeFile(projectManifestPath, JSON.stringify(manifest, null, 2) + "\n");
+    return projectManifestPath;
 }
 /**
  * Merge a built-in template into the project manifest at .claude/gitignore.json.

package/src/services/gitignore-service.ts

@@ -49,8 +49,30 @@ export async function applyAllSafeFixes(
 export async function applyDestructiveFix(
   cwd: string,
   violation: Violation,
+  rulePattern?: string,
 ): Promise<DestructiveFixResult> {
-  return coreApplyDestructiveFix(cwd, violation);
+  return coreApplyDestructiveFix(cwd, violation, rulePattern);
+}
+
+export async function ensureProjectManifestForEdit(
+  cwd: string,
+  resolved: ResolvedManifest,
+): Promise<string> {
+  const projectManifestPath = join(cwd, ".claude", "gitignore.json");
+  if (existsSync(projectManifestPath)) {
+    const existing = await readFile(projectManifestPath, "utf8");
+    if (existing.trim().length > 0) return projectManifestPath;
+  }
+
+  const manifest: GitignoreManifest = { ignore: [], track: [] };
+  for (const rule of resolved.rules) {
+    if (rule.action === "ignore") manifest.ignore.push(rule.pattern);
+    else manifest.track.push(rule.pattern);
+  }
+
+  await mkdir(dirname(projectManifestPath), { recursive: true });
+  await writeFile(projectManifestPath, JSON.stringify(manifest, null, 2) + "\n");
+  return projectManifestPath;
 }
 
 export interface ApplyTemplateResult {