@makehash/nocap 0.0.0-stage → 0.1.0

package/dist/bin.js

@@ -0,0 +1,20 @@
+#!/usr/bin/env node
+import { CoverageCheckUsecase } from './application/coverage/coverage-check.usecase.js';
+import { FileFsFinder } from './infrastructure/filesystem/file.fs.finder.js';
+import { FileFsReader } from './infrastructure/filesystem/file.fs.reader.js';
+import { SpecDocumentMarkdownParser } from './infrastructure/markdown/spec-document.markdown.parser.js';
+import { TestFileTypescriptParser } from './infrastructure/typescript/test-file.typescript.parser.js';
+import { CoverageCheckCommand } from './presentation/cli/coverage-check.command.js';
+import { CoverageCheckTextFormatter } from './presentation/coverage-check.text.formatter.js';
+function hasColors(stream) {
+    if (stream.isTTY)
+        return stream.hasColors();
+    const forceColor = process.env['FORCE_COLOR'];
+    return forceColor !== undefined && forceColor !== '0' && forceColor !== 'false';
+}
+const rootDir = process.cwd();
+const command = new CoverageCheckCommand(new CoverageCheckUsecase(new FileFsFinder(rootDir), new FileFsReader(rootDir), new SpecDocumentMarkdownParser(), new TestFileTypescriptParser()), new CoverageCheckTextFormatter({ stdout: hasColors(process.stdout), stderr: hasColors(process.stderr) }));
+const output = await command.run(process.argv.slice(2));
+process.stdout.write(output.stdout);
+process.stderr.write(output.stderr);
+process.exitCode = output.exitCode;

package/dist/domain/coverage/coverage-problem.d.ts

@@ -0,0 +1,24 @@
+import type { SpecId } from '../spec/spec-id.js';
+import type { SpecItem } from '../spec/spec-item.js';
+import type { TestItem } from '../test/test-item.js';
+/** A spec item whose id no other spec item has, and that no test item points to. */
+export type UncoveredSpec = {
+    readonly kind: 'uncovered-spec';
+    readonly specItem: SpecItem;
+};
+/** An id that test items point to, but that no spec item has. */
+export type UnknownId = {
+    readonly kind: 'unknown-id';
+    readonly id: SpecId;
+    /** The test items that point to the id, in the order they were given. */
+    readonly testItems: readonly [TestItem, ...TestItem[]];
+};
+/** An id that two or more spec items have. Coverage does not judge whether these spec items are covered. */
+export type DuplicateId = {
+    readonly kind: 'duplicate-id';
+    readonly id: SpecId;
+    /** The spec items that have the id, in the order they were given. */
+    readonly specItems: readonly [SpecItem, SpecItem, ...SpecItem[]];
+};
+/** A place where the link between spec items and test items is broken. */
+export type CoverageProblem = UncoveredSpec | UnknownId | DuplicateId;

package/dist/domain/coverage/coverage-problem.js

@@ -0,0 +1 @@
+export {};

package/dist/domain/coverage/coverage.d.ts

@@ -0,0 +1,15 @@
+import type { CoverageProblem } from './coverage-problem.js';
+import type { SpecItem } from '../spec/spec-item.js';
+import type { TestItem } from '../test/test-item.js';
+export declare class Coverage {
+    readonly problems: readonly CoverageProblem[];
+    readonly specCount: number;
+    readonly coveredSpecCount: number;
+    private constructor();
+    static of({ specItems, testItems }: {
+        readonly specItems: readonly SpecItem[];
+        readonly testItems: readonly TestItem[];
+    }): Coverage;
+    private static judgeSpecGroup;
+    private static unknownIdsOf;
+}

package/dist/domain/coverage/coverage.js

@@ -0,0 +1,46 @@
+import { hasTwoOrMore } from '../../lib/array-length.js';
+export class Coverage {
+    problems;
+    specCount;
+    coveredSpecCount;
+    constructor(problems, specCount, coveredSpecCount) {
+        this.problems = problems;
+        this.specCount = specCount;
+        this.coveredSpecCount = coveredSpecCount;
+    }
+    static of({ specItems, testItems }) {
+        const specGroups = groupById(specItems, (specItem) => [specItem.id]);
+        const testGroups = groupById(testItems, (testItem) => testItem.ids.values);
+        const specJudgments = [...specGroups.values()].map((specGroup) => Coverage.judgeSpecGroup(specGroup, testGroups));
+        const unknownIds = Coverage.unknownIdsOf(testGroups, specGroups);
+        return new Coverage([...specJudgments.filter(isProblem), ...unknownIds], specItems.length, specJudgments.filter((judgment) => judgment.kind === 'covered').length);
+    }
+    static judgeSpecGroup({ id, items }, testGroups) {
+        if (hasTwoOrMore(items))
+            return { kind: 'duplicate-id', id, specItems: items };
+        if (testGroups.has(id.key))
+            return { kind: 'covered' };
+        return { kind: 'uncovered-spec', specItem: items[0] };
+    }
+    static unknownIdsOf(testGroups, specGroups) {
+        return [...testGroups.values()]
+            .filter(({ id }) => !specGroups.has(id.key))
+            .map(({ id, items }) => ({ kind: 'unknown-id', id, testItems: items }));
+    }
+}
+function isProblem(judgment) {
+    return judgment.kind !== 'covered';
+}
+function groupById(items, idsOf) {
+    const groups = new Map();
+    for (const item of items) {
+        for (const id of idsOf(item)) {
+            const group = groups.get(id.key);
+            if (group === undefined)
+                groups.set(id.key, { id, items: [item] });
+            else
+                group.items.push(item);
+        }
+    }
+    return groups;
+}

package/dist/domain/shared/id-candidates.d.ts

@@ -0,0 +1,22 @@
+/** The comment body does not start with "nocap:". */
+export type NotTag = {
+    readonly kind: 'not-tag';
+};
+/** "nocap:" has no id after it, or two commas have nothing between them. */
+export type MissingId = {
+    readonly kind: 'missing-id';
+};
+/** The body is a tag and splits into one or more id candidates. */
+type CandidatesFound = {
+    readonly kind: 'candidates';
+    readonly candidates: IdCandidates;
+};
+export declare class IdCandidates {
+    readonly values: readonly [string, ...string[]];
+    private constructor();
+    static parse(body: string): NotTag | MissingId | CandidatesFound;
+    private static textAfterPrefixOf;
+    private static partsOf;
+    private static withoutTrailingComma;
+}
+export {};

package/dist/domain/shared/id-candidates.js

@@ -0,0 +1,34 @@
+import { isNonEmpty } from '../../lib/array-length.js';
+const PREFIX = 'nocap:';
+export class IdCandidates {
+    values;
+    constructor(values) {
+        this.values = values;
+    }
+    static parse(body) {
+        const textAfterPrefix = IdCandidates.textAfterPrefixOf(body);
+        if (textAfterPrefix === undefined) {
+            return { kind: 'not-tag' };
+        }
+        const parts = IdCandidates.partsOf(textAfterPrefix);
+        if (parts.includes('')) {
+            return { kind: 'missing-id' };
+        }
+        return { kind: 'candidates', candidates: new IdCandidates(parts) };
+    }
+    static textAfterPrefixOf(body) {
+        const trimmed = body.trim();
+        return trimmed.startsWith(PREFIX) ? trimmed.slice(PREFIX.length) : undefined;
+    }
+    static partsOf(textAfterPrefix) {
+        const parts = textAfterPrefix.split(',').map((part) => part.trim());
+        const kept = IdCandidates.withoutTrailingComma(parts);
+        if (!isNonEmpty(kept))
+            throw new Error('Splitting a tag body must give at least one part');
+        return kept;
+    }
+    static withoutTrailingComma(parts) {
+        const endsWithComma = parts.length > 1 && parts.at(-1) === '';
+        return endsWithComma ? parts.slice(0, -1) : parts;
+    }
+}

package/dist/domain/shared/location.d.ts

@@ -0,0 +1,8 @@
+export declare class Location {
+    readonly path: string;
+    readonly line: number;
+    private constructor();
+    static of(path: string, line: number): Location;
+    private static assertPathNotEmpty;
+    private static assertLineIsPositiveInteger;
+}

package/dist/domain/shared/location.js

@@ -0,0 +1,22 @@
+export class Location {
+    path;
+    line;
+    constructor(path, line) {
+        this.path = path;
+        this.line = line;
+    }
+    static of(path, line) {
+        Location.assertPathNotEmpty(path);
+        Location.assertLineIsPositiveInteger(line);
+        return new Location(path, line);
+    }
+    static assertPathNotEmpty(path) {
+        if (path === '')
+            throw new Error('Location path must not be empty');
+    }
+    static assertLineIsPositiveInteger(line) {
+        const isPositiveInteger = Number.isInteger(line) && line >= 1;
+        if (!isPositiveInteger)
+            throw new Error(`Location line must be an integer of 1 or more, got ${line}`);
+    }
+}

package/dist/domain/shared/tag-site.boundary.d.ts

@@ -0,0 +1,21 @@
+/**
+ * An item that has a comment at its tag position. The comment body is not checked yet.
+ *
+ * @remarks
+ * The adapter of each format decides the tag position with the syntax of that format.
+ * In a spec document it is the end of the first paragraph of a list item.
+ * In a test file it is the line just above a test call, with no code before the comment on that line.
+ * An item without such a comment is not a tag site.
+ * The adapter does not check the body: a comment such as `TODO` still makes a tag site.
+ * Whether the body is a tag is decided by `Tag.parse`.
+ */
+export type TagSite = {
+    /** 1-based line where the item starts. */
+    readonly line: number;
+    readonly comment: {
+        /** 1-based line where the comment starts. */
+        readonly line: number;
+        /** Text between the comment delimiters, for example between `<!--` and `-->`. Whitespace is kept as written. */
+        readonly body: string;
+    };
+};

package/dist/domain/shared/tag-site.boundary.js

@@ -0,0 +1 @@
+export {};

package/dist/domain/spec/spec-document.d.ts

@@ -0,0 +1,8 @@
+import { SpecItem, type SpecInvalidTag } from './spec-item.js';
+import type { SpecTagSite } from './spec-tag-site.boundary.js';
+export declare class SpecDocument {
+    readonly specItems: readonly SpecItem[];
+    readonly invalidTags: readonly SpecInvalidTag[];
+    private constructor();
+    static of(path: string, sites: readonly SpecTagSite[]): SpecDocument;
+}

package/dist/domain/spec/spec-document.js

@@ -0,0 +1,26 @@
+import { SpecItem } from './spec-item.js';
+export class SpecDocument {
+    specItems;
+    invalidTags;
+    constructor(specItems, invalidTags) {
+        this.specItems = specItems;
+        this.invalidTags = invalidTags;
+    }
+    static of(path, sites) {
+        const specItems = [];
+        const invalidTags = [];
+        for (const site of sites) {
+            const result = SpecItem.parse(path, site);
+            switch (result.kind) {
+                case 'not-tag':
+                    break;
+                case 'valid':
+                    specItems.push(result.item);
+                    break;
+                default:
+                    invalidTags.push(result);
+            }
+        }
+        return new SpecDocument(specItems, invalidTags);
+    }
+}

package/dist/domain/spec/spec-id.d.ts

@@ -0,0 +1,32 @@
+/** The candidate passed the id rule. */
+type ValidSpecId = {
+    readonly kind: 'valid';
+    readonly id: SpecId;
+};
+/**
+ * An id candidate that broke the id rule, with the reason taken from the first character the rule does not allow.
+ *
+ * @remarks
+ * `invalid-whitespace`: the first such character is a whitespace. Ids written without a comma between them give this reason.
+ * `invalid-char`: the first such character is any other character.
+ */
+export type InvalidIdCandidate = {
+    readonly kind: 'invalid-whitespace';
+    readonly value: string;
+} | {
+    readonly kind: 'invalid-char';
+    readonly value: string;
+    /** The first character in the candidate that the id rule does not allow. */
+    readonly firstInvalidChar: string;
+};
+export declare class SpecId {
+    readonly value: string;
+    private constructor();
+    static parse(candidate: string): ValidSpecId | InvalidIdCandidate;
+    get key(): string;
+    equals(other: SpecId): boolean;
+    private static assertNotEmpty;
+    private static invalidCandidateOf;
+    private static firstInvalidCharOf;
+}
+export {};

package/dist/domain/spec/spec-id.js

@@ -0,0 +1,36 @@
+/** One character that the id rule allows: A-Z, a-z, 0-9, "-" or "_". */
+const ID_CHAR = /^[A-Za-z0-9_-]$/u;
+const WHITESPACE = /^\s$/u;
+export class SpecId {
+    value;
+    constructor(value) {
+        this.value = value;
+    }
+    static parse(candidate) {
+        SpecId.assertNotEmpty(candidate);
+        const firstInvalidChar = SpecId.firstInvalidCharOf(candidate);
+        if (firstInvalidChar) {
+            return SpecId.invalidCandidateOf(candidate, firstInvalidChar);
+        }
+        return { kind: 'valid', id: new SpecId(candidate) };
+    }
+    get key() {
+        return this.value;
+    }
+    equals(other) {
+        return this.key === other.key;
+    }
+    static assertNotEmpty(candidate) {
+        if (candidate === '')
+            throw new Error('An id candidate must not be empty');
+    }
+    static invalidCandidateOf(candidate, firstInvalidChar) {
+        return WHITESPACE.test(firstInvalidChar)
+            ? { kind: 'invalid-whitespace', value: candidate }
+            : { kind: 'invalid-char', value: candidate, firstInvalidChar };
+    }
+    static firstInvalidCharOf(candidate) {
+        // oxlint-disable-next-line typescript/no-misused-spread -- an id is checked one code point at a time
+        return [...candidate].find((char) => !ID_CHAR.test(char));
+    }
+}

package/dist/domain/spec/spec-ids.d.ts

@@ -0,0 +1,8 @@
+import type { SpecId } from './spec-id.js';
+export declare class SpecIds {
+    readonly values: readonly [SpecId, ...SpecId[]];
+    private constructor();
+    static of(ids: readonly [SpecId, ...SpecId[]]): SpecIds;
+    private add;
+    private has;
+}

package/dist/domain/spec/spec-ids.js

@@ -0,0 +1,18 @@
+export class SpecIds {
+    values;
+    constructor(values) {
+        this.values = values;
+    }
+    static of(ids) {
+        const [first, ...others] = ids;
+        return others.reduce((specIds, id) => specIds.add(id), new SpecIds([first]));
+    }
+    add(id) {
+        if (this.has(id))
+            return this;
+        return new SpecIds([...this.values, id]);
+    }
+    has(id) {
+        return this.values.some((kept) => kept.equals(id));
+    }
+}

package/dist/domain/spec/spec-item.d.ts

@@ -0,0 +1,30 @@
+import type { NotTag } from '../shared/id-candidates.js';
+import { Location } from '../shared/location.js';
+import type { SpecId } from './spec-id.js';
+import type { SpecTagSite } from './spec-tag-site.boundary.js';
+import { type InvalidTagReason } from './tag.js';
+/** A spec tag has two or more ids. Only spec tags have this reason. */
+type MultipleIds = {
+    readonly kind: 'multiple-ids';
+    readonly ids: readonly [SpecId, SpecId, ...SpecId[]];
+};
+/** Why a comment body that starts with "nocap:" did not become a spec tag. */
+type SpecInvalidTagReason = InvalidTagReason | MultipleIds;
+/** A spec tag that broke a rule, at the line where the tag starts. */
+export type SpecInvalidTag = SpecInvalidTagReason & {
+    readonly location: Location;
+};
+/** The comment of the tag site is a valid spec tag, so the list item became a spec item. */
+type ValidSpecItem = {
+    readonly kind: 'valid';
+    readonly item: SpecItem;
+};
+export declare class SpecItem {
+    readonly id: SpecId;
+    readonly location: Location;
+    readonly text: string;
+    private constructor();
+    static parse(path: string, site: SpecTagSite): NotTag | SpecInvalidTag | ValidSpecItem;
+    private static fromTag;
+}
+export {};

package/dist/domain/spec/spec-item.js

@@ -0,0 +1,34 @@
+import { Location } from '../shared/location.js';
+import { Tag } from './tag.js';
+import { hasTwoOrMore } from '../../lib/array-length.js';
+export class SpecItem {
+    id;
+    location;
+    text;
+    constructor(id, location, text) {
+        this.id = id;
+        this.location = location;
+        this.text = text;
+    }
+    static parse(path, site) {
+        const result = Tag.parse(site.comment.body);
+        switch (result.kind) {
+            case 'not-tag':
+                return result;
+            case 'missing-id':
+            case 'id-rule-violation':
+                return invalid(result, path, site.comment);
+            case 'valid':
+                return SpecItem.fromTag(result.tag, path, site);
+        }
+    }
+    static fromTag(tag, path, { line, text, comment }) {
+        if (hasTwoOrMore(tag.ids)) {
+            return invalid({ kind: 'multiple-ids', ids: tag.ids }, path, comment);
+        }
+        return { kind: 'valid', item: new SpecItem(tag.ids[0], Location.of(path, line), text) };
+    }
+}
+function invalid(reason, path, comment) {
+    return { ...reason, location: Location.of(path, comment.line) };
+}

package/dist/domain/spec/spec-tag-site.boundary.d.ts

@@ -0,0 +1,5 @@
+import type { TagSite } from '../shared/tag-site.boundary.js';
+/** The tag site of a list item. `text` is the spec sentence of the list item. */
+export type SpecTagSite = TagSite & {
+    readonly text: string;
+};

package/dist/domain/spec/spec-tag-site.boundary.js

@@ -0,0 +1 @@
+export {};

package/dist/domain/spec/tag.d.ts

@@ -0,0 +1,21 @@
+import { type MissingId, type NotTag } from '../shared/id-candidates.js';
+import { type InvalidIdCandidate, SpecId } from './spec-id.js';
+/** One or more id candidates of a tag broke the id rule. Each one appears once. */
+type IdRuleViolation = {
+    readonly kind: 'id-rule-violation';
+    readonly invalidCandidates: readonly [InvalidIdCandidate, ...InvalidIdCandidate[]];
+};
+/** Why a comment body that starts with "nocap:" did not become a tag. */
+export type InvalidTagReason = MissingId | IdRuleViolation;
+/** The body is a tag whose ids all passed the id rule. */
+type ValidTag = {
+    readonly kind: 'valid';
+    readonly tag: Tag;
+};
+export declare class Tag {
+    readonly ids: readonly [SpecId, ...SpecId[]];
+    private constructor();
+    static parse(body: string): NotTag | InvalidTagReason | ValidTag;
+    private static fromCandidates;
+}
+export {};

package/dist/domain/spec/tag.js

@@ -0,0 +1,34 @@
+import { isNonEmpty } from '../../lib/array-length.js';
+import { IdCandidates } from '../shared/id-candidates.js';
+import { SpecId } from './spec-id.js';
+export class Tag {
+    ids;
+    constructor(ids) {
+        this.ids = ids;
+    }
+    static parse(body) {
+        const result = IdCandidates.parse(body);
+        switch (result.kind) {
+            case 'not-tag':
+            case 'missing-id':
+                return result;
+            case 'candidates':
+                return Tag.fromCandidates(result.candidates);
+        }
+    }
+    static fromCandidates(candidates) {
+        const results = candidates.values.map((candidate) => SpecId.parse(candidate));
+        const invalidCandidates = withoutDuplicates(results.filter((result) => result.kind !== 'valid'));
+        if (isNonEmpty(invalidCandidates)) {
+            return { kind: 'id-rule-violation', invalidCandidates };
+        }
+        const ids = results.flatMap((result) => (result.kind === 'valid' ? [result.id] : []));
+        if (!isNonEmpty(ids)) {
+            throw new Error('Id candidates with no invalid one must give at least one id');
+        }
+        return { kind: 'valid', tag: new Tag(ids) };
+    }
+}
+function withoutDuplicates(invalidCandidates) {
+    return invalidCandidates.filter((invalid, index) => invalidCandidates.findIndex((other) => other.value === invalid.value) === index);
+}

package/dist/domain/test/test-file.d.ts

@@ -0,0 +1,8 @@
+import type { TagSite } from '../shared/tag-site.boundary.js';
+import { TestItem, type TestInvalidTag } from './test-item.js';
+export declare class TestFile {
+    readonly items: readonly TestItem[];
+    readonly invalidTags: readonly TestInvalidTag[];
+    private constructor();
+    static of(path: string, sites: readonly TagSite[]): TestFile;
+}

package/dist/domain/test/test-file.js

@@ -0,0 +1,26 @@
+import { TestItem } from './test-item.js';
+export class TestFile {
+    items;
+    invalidTags;
+    constructor(items, invalidTags) {
+        this.items = items;
+        this.invalidTags = invalidTags;
+    }
+    static of(path, sites) {
+        const items = [];
+        const invalidTags = [];
+        for (const site of sites) {
+            const result = TestItem.parse(path, site);
+            switch (result.kind) {
+                case 'not-tag':
+                    break;
+                case 'valid':
+                    items.push(result.item);
+                    break;
+                default:
+                    invalidTags.push(result);
+            }
+        }
+        return new TestFile(items, invalidTags);
+    }
+}

package/dist/domain/test/test-item.d.ts

@@ -0,0 +1,22 @@
+import type { NotTag } from '../shared/id-candidates.js';
+import { Location } from '../shared/location.js';
+import type { TagSite } from '../shared/tag-site.boundary.js';
+import { SpecIds } from '../spec/spec-ids.js';
+import { type InvalidTagReason } from '../spec/tag.js';
+/** A test tag that broke a rule, at the line of the tag. */
+export type TestInvalidTag = InvalidTagReason & {
+    readonly location: Location;
+};
+/** The comment of the tag site is a valid test tag, so the test call became a test item. */
+type ValidTestItem = {
+    readonly kind: 'valid';
+    readonly item: TestItem;
+};
+export declare class TestItem {
+    readonly ids: SpecIds;
+    readonly location: Location;
+    private constructor();
+    static parse(path: string, site: TagSite): NotTag | TestInvalidTag | ValidTestItem;
+    private static fromTag;
+}
+export {};

package/dist/domain/test/test-item.js

@@ -0,0 +1,29 @@
+import { Location } from '../shared/location.js';
+import { SpecIds } from '../spec/spec-ids.js';
+import { Tag } from '../spec/tag.js';
+export class TestItem {
+    ids;
+    location;
+    constructor(ids, location) {
+        this.ids = ids;
+        this.location = location;
+    }
+    static parse(path, site) {
+        const result = Tag.parse(site.comment.body);
+        switch (result.kind) {
+            case 'not-tag':
+                return result;
+            case 'missing-id':
+            case 'id-rule-violation':
+                return invalid(result, path, site.comment);
+            case 'valid':
+                return TestItem.fromTag(result.tag, path, site);
+        }
+    }
+    static fromTag(tag, path, { line }) {
+        return { kind: 'valid', item: new TestItem(SpecIds.of(tag.ids), Location.of(path, line)) };
+    }
+}
+function invalid(reason, path, comment) {
+    return { ...reason, location: Location.of(path, comment.line) };
+}

package/dist/index.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/index.js

@@ -0,0 +1 @@
+export {};

package/dist/infrastructure/filesystem/file.fs.finder.d.ts

@@ -0,0 +1,6 @@
+import type { FileFinder } from '../../application/file/file.finder.js';
+export declare class FileFsFinder implements FileFinder {
+    private readonly rootDir;
+    constructor(rootDir: string);
+    find(patterns: readonly [string, ...string[]]): Promise<string[]>;
+}

package/dist/infrastructure/filesystem/file.fs.finder.js

@@ -0,0 +1,17 @@
+import { glob } from 'tinyglobby';
+const EXCLUDED_DIRECTORIES = ['**/node_modules/**', '**/.git/**'];
+export class FileFsFinder {
+    rootDir;
+    constructor(rootDir) {
+        this.rootDir = rootDir;
+    }
+    async find(patterns) {
+        return glob([...patterns], {
+            cwd: this.rootDir,
+            ignore: EXCLUDED_DIRECTORIES,
+            dot: true,
+            onlyFiles: true,
+            expandDirectories: false,
+        });
+    }
+}

package/dist/infrastructure/filesystem/file.fs.reader.d.ts

@@ -0,0 +1,6 @@
+import type { FileReader, FileReadResult } from '../../application/file/file.reader.js';
+export declare class FileFsReader implements FileReader {
+    private readonly rootDir;
+    constructor(rootDir: string);
+    read(path: string): Promise<FileReadResult>;
+}

package/dist/infrastructure/filesystem/file.fs.reader.js

@@ -0,0 +1,20 @@
+import { readFile } from 'node:fs/promises';
+import { join } from 'node:path';
+export class FileFsReader {
+    rootDir;
+    constructor(rootDir) {
+        this.rootDir = rootDir;
+    }
+    async read(path) {
+        try {
+            const content = await readFile(join(this.rootDir, path), 'utf8');
+            return { kind: 'read', content };
+        }
+        catch (error) {
+            return { kind: 'read-error', message: messageOf(error) };
+        }
+    }
+}
+function messageOf(error) {
+    return error instanceof Error ? error.message : String(error);
+}