alignfirst 0.4.0 → 0.6.0-preview.0

package/dist/plans/archive.js

@@ -1,9 +1,11 @@
 import { existsSync, mkdirSync, readdirSync, renameSync, statSync } from "node:fs";
 import { basename, dirname, extname, join, relative } from "node:path";
 import { CliError } from "../cli-error.js";
+import { separateSessionTree } from "../project-layout.js";
 import { isTicketName } from "./layout.js";
 const DEFAULT_ARCHIVE_DAYS = 7;
 const DAY_MS = 86_400_000;
+const SESSION_TREE_LABEL = " (session tree)";
 export function archiveThresholdDays(env) {
     const value = env.ALIGNFIRST_ARCHIVE_DAYS;
     if (value === undefined)
@@ -13,24 +15,35 @@ export function archiveThresholdDays(env) {
         throw new CliError("ALIGNFIRST_ARCHIVE_DAYS must be a positive number of days.");
     return days;
 }
-export function autoArchive(plansDir, thresholdDays, stdout) {
+/**
+ * Archives the stale entries of `.plans`, and of a separate session tree into its own `_archives`.
+ * Returns whether `.plans` changed.
+ */
+export function autoArchive(layout, thresholdDays, stdout) {
     const cutoff = Date.now() - thresholdDays * DAY_MS;
-    const candidates = [
-        ...staleTicketDirectories(plansDir, cutoff),
-        ...staleNoTicketSessionFiles(plansDir, cutoff),
-    ];
-    if (candidates.length === 0) {
+    const plansDir = layout.locations[".plans"].path;
+    const sessionsDir = separateSessionTree(layout);
+    const plansCandidates = staleEntries(plansDir, cutoff);
+    const sessionCandidates = sessionsDir === undefined ? [] : staleEntries(sessionsDir, cutoff);
+    if (plansCandidates.length === 0 && sessionCandidates.length === 0) {
         stdout.write("Nothing to archive.\n");
         return false;
     }
-    for (const candidate of candidates)
+    for (const candidate of plansCandidates)
         archiveEntry(plansDir, candidate, stdout);
-    return true;
+    if (sessionsDir !== undefined) {
+        for (const candidate of sessionCandidates)
+            archiveEntry(sessionsDir, candidate, stdout, SESSION_TREE_LABEL);
+    }
+    return plansCandidates.length > 0;
+}
+function staleEntries(root, cutoff) {
+    return [...staleTicketDirectories(root, cutoff), ...staleNoTicketSessionFiles(root, cutoff)];
 }
-function staleTicketDirectories(plansDir, cutoff) {
-    return readdirSync(plansDir, { withFileTypes: true })
+function staleTicketDirectories(root, cutoff) {
+    return readdirSync(root, { withFileTypes: true })
         .filter((entry) => entry.isDirectory() && isTicketName(entry.name))
-        .map((entry) => join(plansDir, entry.name))
+        .map((entry) => join(root, entry.name))
         .filter((ticketDir) => newestFileMtime(ticketDir) < cutoff);
 }
 function newestFileMtime(dir) {
@@ -39,8 +52,8 @@ function newestFileMtime(dir) {
         return statSync(dir).mtimeMs;
     return Math.max(...files.map((entry) => statSync(join(entry.parentPath, entry.name)).mtimeMs));
 }
-function staleNoTicketSessionFiles(plansDir, cutoff) {
-    const sessionDir = join(plansDir, "_alcode");
+function staleNoTicketSessionFiles(root, cutoff) {
+    const sessionDir = join(root, "_aligndev");
     if (!existsSync(sessionDir))
         return [];
     return readdirSync(sessionDir, { withFileTypes: true })
@@ -48,13 +61,24 @@ function staleNoTicketSessionFiles(plansDir, cutoff) {
         .map((entry) => join(sessionDir, entry.name))
         .filter((path) => statSync(path).mtimeMs < cutoff);
 }
-export function archiveEntry(plansDir, sourcePath, stdout) {
-    const rel = relative(plansDir, sourcePath);
-    const archivesDir = join(plansDir, "_archives");
+/** Archiving ticket `name` also archives its directory in a separate session tree. */
+export function archiveTicket(layout, name, stdout) {
+    const plansDir = layout.locations[".plans"].path;
+    archiveEntry(plansDir, join(plansDir, name), stdout);
+    const sessionsDir = separateSessionTree(layout);
+    if (sessionsDir === undefined)
+        return;
+    const sessionTicketDir = join(sessionsDir, name);
+    if (existsSync(sessionTicketDir))
+        archiveEntry(sessionsDir, sessionTicketDir, stdout, SESSION_TREE_LABEL);
+}
+function archiveEntry(root, sourcePath, stdout, label = "") {
+    const rel = relative(root, sourcePath);
+    const archivesDir = join(root, "_archives");
     const targetDir = join(archivesDir, dirname(rel));
     mkdirSync(targetDir, { recursive: true });
     const target = moveToFreeName(sourcePath, targetDir, statSync(sourcePath).isFile());
-    stdout.write(`Archived ${rel} → _archives/${relative(archivesDir, target)}\n`);
+    stdout.write(`Archived ${rel}${label} → _archives/${relative(archivesDir, target)}\n`);
 }
 function moveToFreeName(sourcePath, targetDir, isFile) {
     const name = basename(sourcePath);

package/dist/plans/catchup.js

@@ -1,8 +1,8 @@
 import { readFileSync } from "node:fs";
-import { join, relative } from "node:path";
+import { join } from "node:path";
 import { CliError } from "../cli-error.js";
 import { errorMessage } from "../errors.js";
-import { formatLocalTimestamp, formatSize } from "../format.js";
+import { displayPath, formatLocalTimestamp, formatSize } from "../format.js";
 const MAX_FILE_BYTES = 64 * 1024;
 const MAX_OUTPUT_BYTES = 30 * 1024;
 const PLAN_FILE = /^[A-Z]\d+-(?:main-plan|plan-.*)\.md$/;
@@ -15,14 +15,16 @@ export function renderCatchup(cwd, ticket, report) {
     const outputBytes = files.reduce((total, file) => total + sectionBytes(file), Buffer.byteLength(report) + 1);
     if (outputBytes > MAX_OUTPUT_BYTES)
         return `${report}\n${TOO_LARGE_NOTICE}\n`;
-    return `${report}\n${files.map((file) => renderSection(cwd, file)).join("")}`;
+    return `${report}\n${files.map(renderSection).join("")}`;
 }
 function catchupFile(cwd, dir, entry) {
     if (entry.size === undefined || !isHistoryFile(entry.name))
         return [];
+    const path = join(dir, entry.name);
     return [
         {
-            path: relative(cwd, join(dir, entry.name)),
+            path,
+            displayPath: displayPath(cwd, path),
             size: entry.size,
             modified: formatLocalTimestamp(entry.modifiedAt),
         },
@@ -39,17 +41,17 @@ function isOversized(file) {
     return file.size > MAX_FILE_BYTES;
 }
 function wrapSection(file, body) {
-    return `<file path="${file.path}" modified="${file.modified}">\n${body}\n</file>\n\n`;
+    return `<file path="${file.displayPath}" modified="${file.modified}">\n${body}\n</file>\n\n`;
 }
-function renderSection(cwd, file) {
-    const body = isOversized(file) ? OMISSION_NOTICE : readBody(cwd, file);
+function renderSection(file) {
+    const body = isOversized(file) ? OMISSION_NOTICE : readBody(file);
     return wrapSection(file, body.replace(/\n+$/, ""));
 }
-function readBody(cwd, file) {
+function readBody(file) {
     try {
-        return readFileSync(join(cwd, file.path), "utf-8");
+        return readFileSync(file.path, "utf-8");
     }
     catch (error) {
-        throw new CliError(`Cannot load catchup file ${file.path}: ${errorMessage(error)}`);
+        throw new CliError(`Cannot load catchup file ${file.displayPath}: ${errorMessage(error)}`);
     }
 }

package/dist/plans/layout.d.ts

@@ -1,11 +1,8 @@
 import { type Stats } from "node:fs";
-import { CliError } from "../cli-error.js";
-export declare const PLANS_DIR = ".plans";
+import type { ItemLocation } from "../project-layout.js";
 export declare const ARCHIVES_DIR = "_archives";
 export declare function isTicketName(name: string): boolean;
-export declare function plansDir(cwd: string): string;
-export declare function archivesDir(cwd: string): string;
+export declare function archivesDir(plansPath: string): string;
 /** Returns the lstat of `.plans`, so callers can tell a symlink from a directory. */
-export declare function assertPlansGate(cwd: string, form: string): Stats;
-export declare function missingPlansMessage(form: string): string;
-export declare function missingPlansError(form: string): CliError;
+export declare function assertPlansGate(location: ItemLocation, form: string): Stats;
+export declare function missingPlansMessage(location: ItemLocation, form: string): string;

package/dist/plans/layout.js

@@ -1,32 +1,28 @@
 import { existsSync, lstatSync, statSync } from "node:fs";
 import { join } from "node:path";
 import { CliError } from "../cli-error.js";
-export const PLANS_DIR = ".plans";
 export const ARCHIVES_DIR = "_archives";
 export function isTicketName(name) {
     return !name.startsWith("_");
 }
-export function plansDir(cwd) {
-    return join(cwd, PLANS_DIR);
-}
-export function archivesDir(cwd) {
-    return join(plansDir(cwd), ARCHIVES_DIR);
+export function archivesDir(plansPath) {
+    return join(plansPath, ARCHIVES_DIR);
 }
 /** Returns the lstat of `.plans`, so callers can tell a symlink from a directory. */
-export function assertPlansGate(cwd, form) {
-    const path = plansDir(cwd);
+export function assertPlansGate(location, form) {
+    const { path } = location;
     const stats = lstatSync(path, { throwIfNoEntry: false });
     if (!stats)
-        throw missingPlansError(form);
+        throw new CliError(missingPlansMessage(location, form));
     if (stats.isSymbolicLink() && !existsSync(path))
         throw new CliError(`The .plans symlink is broken. Re-run ${form} plans setup with the clone location.`);
     if (!statSync(path).isDirectory())
         throw new CliError(`.plans is not a directory. Remove it, then run ${form} plans setup (see the project documentation).`);
     return stats;
 }
-export function missingPlansMessage(form) {
-    return `No .plans/ directory in the current directory.\nLocal work files:  mkdir .plans && echo .plans >> .gitignore\nTeam work files:   ${form} plans setup <clone-dir>`;
-}
-export function missingPlansError(form) {
-    return new CliError(missingPlansMessage(form));
+export function missingPlansMessage(location, form) {
+    const team = `Team work files:   ${form} plans setup <clone-dir>`;
+    if (location.in === "companion")
+        return `No .plans/ directory at ${location.path} (companion).\nLocal work files:  mkdir -p ${location.path}\n${team}`;
+    return `No .plans/ directory in the current directory.\nLocal work files:  mkdir .plans && echo .plans >> .gitignore\n${team}`;
 }

package/dist/plans/link.d.ts

@@ -1,2 +1,2 @@
 import type { CommandContext } from "../context.js";
-export declare function linkPlans(ctx: CommandContext, targetDir: string): void;
+export declare function linkPlans(ctx: CommandContext, plansPath: string, targetDir: string): void;

package/dist/plans/link.js

@@ -1,8 +1,8 @@
-import { cpSync, existsSync, lstatSync, readdirSync, realpathSync, rmSync, symlinkSync, } from "node:fs";
-import { join, relative } from "node:path";
+import { cpSync, existsSync, lstatSync, mkdirSync, readdirSync, realpathSync, rmSync, symlinkSync, } from "node:fs";
+import { dirname, join, relative } from "node:path";
 import { CliError } from "../cli-error.js";
-export function linkPlans(ctx, targetDir) {
-    const plansPath = join(ctx.cwd, ".plans");
+import { displayPath } from "../format.js";
+export function linkPlans(ctx, plansPath, targetDir) {
     const stats = lstatSync(plansPath, { throwIfNoEntry: false });
     if (stats?.isSymbolicLink()) {
         if (existsSync(plansPath) && realpathSync(plansPath) === realpathSync(targetDir)) {
@@ -17,9 +17,11 @@ export function linkPlans(ctx, targetDir) {
     else if (stats) {
         throw new CliError(".plans exists and is not a directory.");
     }
-    const target = relative(ctx.cwd, targetDir);
+    const parent = dirname(plansPath);
+    mkdirSync(parent, { recursive: true });
+    const target = relative(parent, targetDir);
     symlinkSync(target, plansPath);
-    ctx.stdout.write(`Linked .plans → ${target}\n`);
+    ctx.stdout.write(`Linked ${displayPath(ctx.cwd, plansPath)} → ${target}\n`);
     ctx.stdout.write(`Publish with: ${ctx.form} sync\n`);
 }
 function migratePlansContent(ctx, plansPath, targetDir) {

package/dist/plans/mode.d.ts

@@ -1,3 +1,4 @@
+import type { ItemLocation } from "../project-layout.js";
 export type PlansMode = SharedPlans | LocalPlans;
 export interface SharedPlans {
     kind: "shared";
@@ -6,4 +7,5 @@ export interface SharedPlans {
 export interface LocalPlans {
     kind: "local";
 }
-export declare function resolvePlansMode(cwd: string, form: string): PlansMode;
+/** `.plans` is shared when it sits in another repository than the project's. */
+export declare function resolvePlansMode(cwd: string, location: ItemLocation, form: string): PlansMode;

package/dist/plans/mode.js

@@ -1,15 +1,19 @@
 import { realpathSync } from "node:fs";
-import { join } from "node:path";
 import { CliError } from "../cli-error.js";
 import { gitOutput } from "../git.js";
 import { assertPlansGate } from "./layout.js";
-export function resolvePlansMode(cwd, form) {
-    const plansPath = join(cwd, ".plans");
-    const stats = assertPlansGate(cwd, form);
-    if (plansRepositoryId(plansPath, stats.isSymbolicLink(), form) === repositoryId(cwd))
+/** `.plans` is shared when it sits in another repository than the project's. */
+export function resolvePlansMode(cwd, location, form) {
+    const stats = assertPlansGate(location, form);
+    const plansRepository = plansRepositoryId(location.path, stats.isSymbolicLink(), form);
+    if (plansRepository === undefined || plansRepository === repositoryId(cwd))
         return { kind: "local" };
-    return { kind: "shared", repoToplevel: gitOutput(plansPath, "rev-parse", "--show-toplevel") };
+    return {
+        kind: "shared",
+        repoToplevel: gitOutput(location.path, "rev-parse", "--show-toplevel"),
+    };
 }
+/** Returns `undefined` for a real directory outside any git repository. */
 function plansRepositoryId(plansPath, isSymlink, form) {
     try {
         return repositoryId(plansPath);
@@ -17,7 +21,7 @@ function plansRepositoryId(plansPath, isSymlink, form) {
     catch {
         if (isSymlink)
             throw new CliError(`.plans points outside any git repository. Re-run ${form} plans setup with the clone location.`);
-        throw new CliError(".plans is not inside a git repository. Run this command from a worktree root.");
+        return;
     }
 }
 function repositoryId(dir) {

package/dist/plans/ticket.d.ts

@@ -1,3 +1,4 @@
+import { type ProjectLayout } from "../project-layout.js";
 export interface ResolvedTicketDir {
     id: string;
     dir: string;
@@ -27,9 +28,11 @@ export type TicketDetection = {
 } | {
     kind: "noBranch";
 };
-export declare function resolveTicketDir(cwd: string, id: string, { dryRun }: ResolveTicketOptions): ResolvedTicketDir;
-export declare function reserveSideTicket(cwd: string): string;
-export declare function peekSideTicket(cwd: string): string;
+export declare function resolveTicketDir(plansPath: string, id: string, { dryRun }: ResolveTicketOptions): ResolvedTicketDir;
+/** Restores ticket `id` in a separate session tree, when only its archived copy exists. */
+export declare function restoreSessionTreeTicket(layout: ProjectLayout, id: string): void;
+export declare function reserveSideTicket(plansPath: string): string;
+export declare function peekSideTicket(plansPath: string): string;
 export interface NextFilePosition {
     cycleLetter: string;
     fileNumber: number;
@@ -43,4 +46,4 @@ export interface DeduceFromExistingOptions {
     sideAllowed: boolean;
 }
 /** Without a ticket id pattern, the branch can still name an existing ticket directory. */
-export declare function deduceTicketFromExisting(cwd: string, { sideAllowed }: DeduceFromExistingOptions): DeducedTicket;
+export declare function deduceTicketFromExisting(cwd: string, plansPath: string, { sideAllowed }: DeduceFromExistingOptions): DeducedTicket;

package/dist/plans/ticket.js

@@ -4,7 +4,8 @@ import { CliError } from "../cli-error.js";
 import { isNodeError } from "../errors.js";
 import { formatLocalTimestamp } from "../format.js";
 import { gitOutputOrUndefined } from "../git.js";
-import { archivesDir, isTicketName, plansDir } from "./layout.js";
+import { separateSessionTree } from "../project-layout.js";
+import { archivesDir, isTicketName } from "./layout.js";
 const FILE_PREFIX = /^([A-Z])(\d+)-/;
 const SIDE_TICKET = /^side-(\d+)$/;
 const BRANCH_SEPARATORS = "[/_.-]";
@@ -12,11 +13,11 @@ const SIDE_TICKET_BRANCH = new RegExp(`^side-\\d+(?=$|${BRANCH_SEPARATORS})`);
 const PATH_SAFE_TICKET = /^[A-Za-z0-9._-]+$/;
 const ENTRY_ORDER = new Intl.Collator("en", { numeric: true });
 const LISTED_TICKETS = 10;
-export function resolveTicketDir(cwd, id, { dryRun }) {
-    const dir = join(plansDir(cwd), id);
+export function resolveTicketDir(plansPath, id, { dryRun }) {
+    const dir = join(plansPath, id);
     if (existsSync(dir))
         return { id, dir, state: "existing", entries: listEntries(dir) };
-    const archivedDir = join(archivesDir(cwd), id);
+    const archivedDir = join(archivesDir(plansPath), id);
     if (existsSync(archivedDir)) {
         const entries = listEntries(archivedDir);
         if (!dryRun)
@@ -27,13 +28,21 @@ export function resolveTicketDir(cwd, id, { dryRun }) {
         mkdirSync(dir);
     return { id, dir, state: "created", entries: [] };
 }
-export function reserveSideTicket(cwd) {
-    const root = plansDir(cwd);
-    const highest = Math.max(highestSideTicket(root), highestSideTicket(archivesDir(cwd)));
-    for (let number = highest + 1;; ++number) {
+/** Restores ticket `id` in a separate session tree, when only its archived copy exists. */
+export function restoreSessionTreeTicket(layout, id) {
+    const sessionsDir = separateSessionTree(layout);
+    if (sessionsDir === undefined)
+        return;
+    const dir = join(sessionsDir, id);
+    const archivedDir = join(archivesDir(sessionsDir), id);
+    if (!existsSync(dir) && existsSync(archivedDir))
+        renameSync(archivedDir, dir);
+}
+export function reserveSideTicket(plansPath) {
+    for (let number = highestSideTicket(plansPath) + 1;; ++number) {
         const ticket = `side-${number}`;
         try {
-            mkdirSync(join(root, ticket));
+            mkdirSync(join(plansPath, ticket));
             return ticket;
         }
         catch (error) {
@@ -42,16 +51,17 @@ export function reserveSideTicket(cwd) {
         }
     }
 }
-export function peekSideTicket(cwd) {
-    const root = plansDir(cwd);
-    const highest = Math.max(highestSideTicket(root), highestSideTicket(archivesDir(cwd)));
-    for (let number = highest + 1;; ++number) {
+export function peekSideTicket(plansPath) {
+    for (let number = highestSideTicket(plansPath) + 1;; ++number) {
         const ticket = `side-${number}`;
-        if (!existsSync(join(root, ticket)))
+        if (!existsSync(join(plansPath, ticket)))
             return ticket;
     }
 }
-function highestSideTicket(dir) {
+function highestSideTicket(plansPath) {
+    return Math.max(highestSideTicketIn(plansPath), highestSideTicketIn(archivesDir(plansPath)));
+}
+function highestSideTicketIn(dir) {
     let highest = 0;
     for (const entry of readEntries(dir)) {
         const match = entry.isDirectory() ? SIDE_TICKET.exec(entry.name) : null;
@@ -153,8 +163,8 @@ function currentBranch(cwd) {
     return branch === undefined || branch === "" ? undefined : branch;
 }
 /** Without a ticket id pattern, the branch can still name an existing ticket directory. */
-export function deduceTicketFromExisting(cwd, { sideAllowed }) {
-    const tickets = listTickets(cwd);
+export function deduceTicketFromExisting(cwd, plansPath, { sideAllowed }) {
+    const tickets = listTickets(plansPath);
     const branch = currentBranch(cwd);
     if (branch !== undefined) {
         const matches = tickets.filter((ticket) => branchNamesTicket(branch, ticket.id));
@@ -163,10 +173,10 @@ export function deduceTicketFromExisting(cwd, { sideAllowed }) {
     }
     throw new CliError(renderMissingTicketId(tickets, sideAllowed));
 }
-function listTickets(cwd) {
+function listTickets(plansPath) {
     return [
-        ...ticketDirectories(plansDir(cwd), false),
-        ...ticketDirectories(archivesDir(cwd), true),
+        ...ticketDirectories(plansPath, false),
+        ...ticketDirectories(archivesDir(plansPath), true),
     ].toSorted((left, right) => right.modifiedAt.getTime() - left.modifiedAt.getTime());
 }
 function ticketDirectories(dir, archived) {

package/dist/project-config.d.ts

@@ -1,3 +1,4 @@
+import type { ProjectLayout } from "./project-layout.js";
 export declare const PROJECT_CONFIG_FILENAME = ".alignfirst.json";
 export interface ProjectConfig {
     schemaVersion: 1;
@@ -27,8 +28,8 @@ export interface CommitConfig {
 }
 export interface ResolvedProjectConfig {
     config: ProjectConfig;
-    source: "root";
+    source: "project" | "companion";
 }
-export declare function resolveProjectConfig(cwd: string): ResolvedProjectConfig | undefined;
-export declare function readProjectConfig(dir: string): ProjectConfig | undefined;
+export declare function resolveProjectConfig(layout: ProjectLayout): ResolvedProjectConfig | undefined;
+export declare function readProjectConfig(path: string): ProjectConfig;
 export declare function validateProjectConfig(value: unknown, label: string): ProjectConfig;

package/dist/project-config.js

@@ -1,5 +1,4 @@
-import { existsSync, readFileSync } from "node:fs";
-import { join } from "node:path";
+import { readFileSync } from "node:fs";
 import { type } from "arktype";
 import semver from "semver";
 import { CliError } from "./cli-error.js";
@@ -36,14 +35,13 @@ const projectConfigSchema = type({
     "portRange?": portRangeSchema,
     "git?": gitSchema,
 });
-export function resolveProjectConfig(cwd) {
-    const config = readProjectConfig(cwd);
-    return config === undefined ? undefined : { config, source: "root" };
-}
-export function readProjectConfig(dir) {
-    const path = join(dir, PROJECT_CONFIG_FILENAME);
-    if (!existsSync(path))
+export function resolveProjectConfig(layout) {
+    const location = layout.locations[PROJECT_CONFIG_FILENAME];
+    if (!location.exists)
         return;
+    return { config: readProjectConfig(location.path), source: location.in };
+}
+export function readProjectConfig(path) {
     let value;
     try {
         value = JSON.parse(readFileSync(path, "utf-8"));

package/dist/project-layout.d.ts

@@ -0,0 +1,30 @@
+import type { CommandContext } from "./context.js";
+export declare const ITEM_NAMES: readonly [".alignfirst.json", ".alignfirst.md", "DEVELOPERS.md", "docs", ".plans", "_aligndev"];
+export type ItemName = (typeof ITEM_NAMES)[number];
+export type Flag = boolean | "auto";
+export interface ProjectLayout {
+    companion: CompanionLayout | null;
+    locations: Record<ItemName, ItemLocation>;
+}
+export interface CompanionLayout {
+    /** Absolute. */
+    dir: string;
+    exists: boolean;
+    /** Matching keys as written, most specific first. */
+    entries: string[];
+    /** Effective flags. */
+    flags: Record<ItemName, Flag>;
+}
+export interface ItemLocation {
+    /** Absolute. */
+    path: string;
+    in: "project" | "companion";
+    exists: boolean;
+}
+export declare function layoutOf(ctx: CommandContext): ProjectLayout;
+export declare function resolveProjectLayout(cwd: string, home: string): ProjectLayout;
+export declare function companionsPath(home: string): string;
+/** One line: `<name>: <path> (<in>)`, with `, missing` when absent. */
+export declare function renderItemLocation(name: ItemName, location: ItemLocation): string;
+/** The `_aligndev` tree when it is not the resolved `.plans` and exists. */
+export declare function separateSessionTree(layout: ProjectLayout): string | undefined;