stego-cli 0.4.0 → 0.4.2

package/dist/stego-cli/src/modules/manuscript/commands/new-manuscript.js

@@ -0,0 +1,54 @@
+import { writeJson, writeText } from "../../../app/output-renderer.js";
+import { resolveProjectContext } from "../../project/index.js";
+import { resolveWorkspaceContext } from "../../workspace/index.js";
+import { createNewManuscript, parseManuscriptOutputFormat } from "../application/create-manuscript.js";
+export function registerNewManuscriptCommand(registry) {
+    registry.register({
+        name: "new",
+        description: "Create a new manuscript file",
+        options: [
+            { flags: "--project <project-id>", description: "Project id" },
+            { flags: "-i, --i <prefix>", description: "Numeric filename prefix override" },
+            { flags: "--filename <name>", description: "Explicit manuscript filename" },
+            { flags: "--format <format>", description: "text|json" },
+            { flags: "--root <path>", description: "Workspace root path" }
+        ],
+        action: (context) => {
+            const workspace = resolveWorkspaceContext({
+                cwd: context.cwd,
+                rootOption: readStringOption(context.options, "root")
+            });
+            const project = resolveProjectContext({
+                workspace,
+                cwd: context.cwd,
+                env: context.env,
+                explicitProjectId: readStringOption(context.options, "project")
+            });
+            const result = createNewManuscript({
+                project,
+                requestedPrefixRaw: readStringOption(context.options, "i"),
+                requestedFilenameRaw: readStringOption(context.options, "filename")
+            });
+            const outputFormat = parseManuscriptOutputFormat(readStringOption(context.options, "format"));
+            if (outputFormat === "json") {
+                writeJson({
+                    ok: true,
+                    operation: "new",
+                    result
+                });
+                return;
+            }
+            writeText(`Created manuscript: ${result.filePath}`);
+        }
+    });
+}
+function readStringOption(options, key) {
+    const value = options[key];
+    if (typeof value === "string") {
+        return value;
+    }
+    if (typeof value === "number") {
+        return String(value);
+    }
+    return undefined;
+}

package/dist/stego-cli/src/modules/manuscript/domain/manuscript.js

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

package/dist/stego-cli/src/modules/manuscript/index.js

@@ -0,0 +1,9 @@
+import { registerNewManuscriptCommand } from "./commands/new-manuscript.js";
+export const manuscriptModule = {
+    registerCommands(registry) {
+        registerNewManuscriptCommand(registry);
+    }
+};
+export * from "./types.js";
+export * from "./application/create-manuscript.js";
+export * from "./application/order-inference.js";

package/dist/stego-cli/src/modules/manuscript/infra/manuscript-repo.js

@@ -0,0 +1,39 @@
+import fs from "node:fs";
+import path from "node:path";
+export function ensureManuscriptDir(manuscriptDir) {
+    fs.mkdirSync(manuscriptDir, { recursive: true });
+}
+export function fileExists(filePath) {
+    return fs.existsSync(filePath);
+}
+export function writeTextFile(filePath, content) {
+    fs.writeFileSync(filePath, content, "utf8");
+}
+export function listManuscriptOrderEntries(manuscriptDir) {
+    if (!fs.existsSync(manuscriptDir)) {
+        return [];
+    }
+    return fs
+        .readdirSync(manuscriptDir, { withFileTypes: true })
+        .filter((entry) => entry.isFile() && entry.name.endsWith(".md"))
+        .map((entry) => {
+        const match = entry.name.match(/^(\d+)[-_]/);
+        if (!match) {
+            return null;
+        }
+        return {
+            order: Number(match[1]),
+            filename: entry.name
+        };
+    })
+        .filter((entry) => entry !== null)
+        .sort((a, b) => {
+        if (a.order === b.order) {
+            return a.filename.localeCompare(b.filename);
+        }
+        return a.order - b.order;
+    });
+}
+export function joinPath(...parts) {
+    return path.join(...parts);
+}

package/dist/stego-cli/src/modules/manuscript/types.js

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

package/dist/stego-cli/src/modules/metadata/application/apply-metadata.js

@@ -0,0 +1,45 @@
+import { CliError } from "../../../../../shared/src/contracts/cli/index.js";
+import { normalizeFrontmatterRecord, parseMarkdownDocument, serializeMarkdownDocument } from "../domain/metadata.js";
+import { readJsonPayload, readMarkdownFile, resolveMarkdownPath, writeMarkdownFile } from "../infra/metadata-repo.js";
+export function applyMetadata(input) {
+    const absolutePath = resolveMarkdownPath(input.cwd, input.markdownPath);
+    const raw = readMarkdownFile(absolutePath, input.markdownPath);
+    const payload = readJsonPayload(input.inputPath, input.cwd);
+    let frontmatter;
+    try {
+        frontmatter = normalizeFrontmatterRecord(payload.frontmatter);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw new CliError("INVALID_PAYLOAD", message);
+    }
+    const body = typeof payload.body === "string" ? payload.body : undefined;
+    const hasFrontmatter = typeof payload.hasFrontmatter === "boolean"
+        ? payload.hasFrontmatter
+        : undefined;
+    const existing = parseMarkdownDocument(raw);
+    const next = {
+        lineEnding: existing.lineEnding,
+        hasFrontmatter: hasFrontmatter ?? (existing.hasFrontmatter || Object.keys(frontmatter).length > 0),
+        frontmatter,
+        body: body ?? existing.body
+    };
+    const nextText = serializeMarkdownDocument(next);
+    const changed = nextText !== raw;
+    if (changed) {
+        writeMarkdownFile(absolutePath, nextText);
+    }
+    const reparsed = parseMarkdownDocument(nextText);
+    return {
+        ok: true,
+        operation: "apply",
+        changed,
+        state: {
+            path: absolutePath,
+            hasFrontmatter: reparsed.hasFrontmatter,
+            lineEnding: reparsed.lineEnding,
+            frontmatter: reparsed.frontmatter,
+            body: reparsed.body
+        }
+    };
+}

package/dist/stego-cli/src/modules/metadata/application/read-metadata.js

@@ -0,0 +1,18 @@
+import { parseMarkdownDocument } from "../domain/metadata.js";
+import { readMarkdownFile, resolveMarkdownPath } from "../infra/metadata-repo.js";
+export function readMetadata(input) {
+    const absolutePath = resolveMarkdownPath(input.cwd, input.markdownPath);
+    const raw = readMarkdownFile(absolutePath, input.markdownPath);
+    const parsed = parseMarkdownDocument(raw);
+    return {
+        ok: true,
+        operation: "read",
+        state: {
+            path: absolutePath,
+            hasFrontmatter: parsed.hasFrontmatter,
+            lineEnding: parsed.lineEnding,
+            frontmatter: parsed.frontmatter,
+            body: parsed.body
+        }
+    };
+}

package/dist/stego-cli/src/modules/metadata/commands/metadata-apply.js

@@ -0,0 +1,38 @@
+import { CliError } from "../../../../../shared/src/contracts/cli/index.js";
+import { writeJson, writeText } from "../../../app/output-renderer.js";
+import { applyMetadata } from "../application/apply-metadata.js";
+import { parseMetadataOutputFormat } from "../infra/metadata-repo.js";
+export function registerMetadataApplyCommand(registry) {
+    registry.register({
+        name: "metadata apply <markdown-path>",
+        description: "Apply frontmatter metadata",
+        options: [
+            { flags: "--input <path>", description: "JSON payload path or '-'" },
+            { flags: "--format <format>", description: "text|json" }
+        ],
+        action: (context) => {
+            const markdownPath = context.positionals[0];
+            if (!markdownPath) {
+                throw new CliError("INVALID_USAGE", "Markdown path is required. Use: stego metadata apply <path> --input <path|->.");
+            }
+            const inputPath = readOption(context.options, "input");
+            if (typeof inputPath !== "string" || inputPath.trim().length === 0) {
+                throw new CliError("INVALID_USAGE", "--input <path|-> is required for 'metadata apply'.");
+            }
+            const outputFormat = parseMetadataOutputFormat(readOption(context.options, "format"));
+            const result = applyMetadata({
+                cwd: context.cwd,
+                markdownPath,
+                inputPath
+            });
+            if (outputFormat === "json") {
+                writeJson(result);
+                return;
+            }
+            writeText(`${result.changed ? "Updated" : "No changes for"} metadata in ${result.state.path}.`);
+        }
+    });
+}
+function readOption(options, key) {
+    return options[key];
+}

package/dist/stego-cli/src/modules/metadata/commands/metadata-read.js

@@ -0,0 +1,33 @@
+import { CliError } from "../../../../../shared/src/contracts/cli/index.js";
+import { writeJson, writeText } from "../../../app/output-renderer.js";
+import { readMetadata } from "../application/read-metadata.js";
+import { parseMetadataOutputFormat } from "../infra/metadata-repo.js";
+export function registerMetadataReadCommand(registry) {
+    registry.register({
+        name: "metadata read <markdown-path>",
+        description: "Read frontmatter metadata",
+        options: [
+            { flags: "--format <format>", description: "text|json" }
+        ],
+        action: (context) => {
+            const markdownPath = context.positionals[0];
+            if (!markdownPath) {
+                throw new CliError("INVALID_USAGE", "Markdown path is required. Use: stego metadata read <path>.");
+            }
+            const outputFormat = parseMetadataOutputFormat(readOption(context.options, "format"));
+            const result = readMetadata({
+                cwd: context.cwd,
+                markdownPath
+            });
+            if (outputFormat === "json") {
+                writeJson(result);
+                return;
+            }
+            const keyCount = Object.keys(result.state.frontmatter).length;
+            writeText(`Read metadata for ${result.state.path} (${keyCount} keys).`);
+        }
+    });
+}
+function readOption(options, key) {
+    return options[key];
+}

package/dist/stego-cli/src/modules/metadata/domain/metadata.js

@@ -0,0 +1 @@
+export { parseMarkdownDocument, serializeMarkdownDocument, normalizeFrontmatterRecord } from "../../../../../shared/src/domain/frontmatter/index.js";

package/dist/stego-cli/src/modules/metadata/index.js

@@ -0,0 +1,11 @@
+import { registerMetadataReadCommand } from "./commands/metadata-read.js";
+import { registerMetadataApplyCommand } from "./commands/metadata-apply.js";
+export const metadataModule = {
+    registerCommands(registry) {
+        registerMetadataReadCommand(registry);
+        registerMetadataApplyCommand(registry);
+    }
+};
+export * from "./types.js";
+export * from "./application/read-metadata.js";
+export * from "./application/apply-metadata.js";

package/dist/stego-cli/src/modules/metadata/infra/metadata-repo.js

@@ -0,0 +1,68 @@
+import fs from "node:fs";
+import path from "node:path";
+import { CliError } from "../../../../../shared/src/contracts/cli/index.js";
+export function parseMetadataOutputFormat(rawValue) {
+    if (rawValue === undefined || rawValue === null || rawValue === "text") {
+        return "text";
+    }
+    if (rawValue === "json") {
+        return "json";
+    }
+    throw new CliError("INVALID_USAGE", "Invalid --format value. Use 'text' or 'json'.");
+}
+export function resolveMarkdownPath(cwd, markdownPath) {
+    return path.resolve(cwd, markdownPath);
+}
+export function readMarkdownFile(absolutePath, originalArg) {
+    try {
+        const stat = fs.statSync(absolutePath);
+        if (!stat.isFile()) {
+            throw new Error("Not a file");
+        }
+    }
+    catch {
+        throw new CliError("INVALID_USAGE", `Markdown file not found: ${originalArg}`);
+    }
+    try {
+        return fs.readFileSync(absolutePath, "utf8");
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw new CliError("INVALID_USAGE", `Unable to read markdown file: ${message}`);
+    }
+}
+export function writeMarkdownFile(absolutePath, contents) {
+    try {
+        fs.writeFileSync(absolutePath, contents, "utf8");
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw new CliError("WRITE_FAILURE", `Failed to update markdown file: ${message}`);
+    }
+}
+export function readJsonPayload(inputPath, cwd) {
+    let rawPayload = "";
+    try {
+        rawPayload = inputPath === "-"
+            ? fs.readFileSync(0, "utf8")
+            : fs.readFileSync(path.resolve(cwd, inputPath), "utf8");
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw new CliError("INVALID_PAYLOAD", `Unable to read input payload: ${message}`);
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(rawPayload);
+    }
+    catch {
+        throw new CliError("INVALID_PAYLOAD", "Input payload is not valid JSON.");
+    }
+    if (!isPlainObject(parsed)) {
+        throw new CliError("INVALID_PAYLOAD", "Input payload must be a JSON object.");
+    }
+    return parsed;
+}
+function isPlainObject(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}

package/dist/stego-cli/src/modules/metadata/types.js

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

package/dist/stego-cli/src/modules/project/application/create-project.js

@@ -0,0 +1,203 @@
+import fs from "node:fs";
+import path from "node:path";
+import { CliError } from "../../../../../shared/src/contracts/cli/index.js";
+import { isValidProjectId } from "../../../../../shared/src/domain/project/index.js";
+import { ensureDirectory, pathExists, writeTextFile } from "../infra/project-repo.js";
+const PROJECT_EXTENSION_RECOMMENDATIONS = [
+    "matt-gold.stego-extension",
+    "matt-gold.saurus-extension",
+    "streetsidesoftware.code-spell-checker"
+];
+const PROSE_MARKDOWN_EDITOR_SETTINGS = {
+    "[markdown]": {
+        "editor.fontFamily": "Inter, Helvetica Neue, Helvetica, Arial, sans-serif",
+        "editor.fontSize": 17,
+        "editor.lineHeight": 28,
+        "editor.wordWrap": "wordWrapColumn",
+        "editor.wordWrapColumn": 72,
+        "editor.lineNumbers": "off"
+    },
+    "markdown.preview.fontFamily": "Inter, Helvetica Neue, Helvetica, Arial, sans-serif"
+};
+export function createProject(input) {
+    const projectId = (input.projectId || "").trim();
+    if (!projectId) {
+        throw new CliError("INVALID_USAGE", "Project id is required. Use --project <project-id>.");
+    }
+    if (!isValidProjectId(projectId)) {
+        throw new CliError("INVALID_USAGE", "Project id must match /^[a-z0-9][a-z0-9-]*$/.");
+    }
+    const projectRoot = path.join(input.workspace.repoRoot, input.workspace.config.projectsDir, projectId);
+    if (pathExists(projectRoot)) {
+        throw new CliError("INVALID_USAGE", `Project already exists: ${projectRoot}`);
+    }
+    const manuscriptDir = path.join(projectRoot, input.workspace.config.chapterDir);
+    const spineDir = path.join(projectRoot, input.workspace.config.spineDir);
+    const notesDir = path.join(projectRoot, input.workspace.config.notesDir);
+    const distDir = path.join(projectRoot, input.workspace.config.distDir);
+    ensureDirectory(manuscriptDir);
+    ensureDirectory(spineDir);
+    ensureDirectory(notesDir);
+    ensureDirectory(distDir);
+    const projectJsonPath = path.join(projectRoot, "stego-project.json");
+    writeTextFile(projectJsonPath, `${JSON.stringify({
+        id: projectId,
+        title: input.title?.trim() || toDisplayTitle(projectId),
+        requiredMetadata: ["status"],
+        compileStructure: {
+            levels: [
+                {
+                    key: "chapter",
+                    label: "Chapter",
+                    titleKey: "chapter_title",
+                    injectHeading: true,
+                    headingTemplate: "{label} {value}: {title}",
+                    pageBreak: "between-groups"
+                }
+            ]
+        }
+    }, null, 2)}\n`);
+    const projectPackagePath = path.join(projectRoot, "package.json");
+    writeTextFile(projectPackagePath, `${JSON.stringify({
+        name: `stego-project-${projectId}`,
+        private: true,
+        scripts: {
+            new: "npx --no-install stego new",
+            "spine:new": "npx --no-install stego spine new",
+            "spine:new-category": "npx --no-install stego spine new-category",
+            lint: "npx --no-install stego lint",
+            validate: "npx --no-install stego validate",
+            build: "npx --no-install stego build",
+            "check-stage": "npx --no-install stego check-stage",
+            export: "npx --no-install stego export"
+        }
+    }, null, 2)}\n`);
+    const starterManuscriptPath = path.join(manuscriptDir, "100-hello-world.md");
+    writeTextFile(starterManuscriptPath, `---
+status: draft
+chapter: 1
+chapter_title: Hello World
+---
+
+# Hello World
+
+Start writing here.
+`);
+    const charactersDir = path.join(spineDir, "characters");
+    ensureDirectory(charactersDir);
+    const charactersCategoryPath = path.join(charactersDir, "_category.md");
+    writeTextFile(charactersCategoryPath, `---
+label: Characters
+---
+
+# Characters
+
+`);
+    const charactersEntryPath = path.join(charactersDir, "example-character.md");
+    writeTextFile(charactersEntryPath, "# Example Character\n\n");
+    const projectExtensionsPath = ensureProjectExtensionsRecommendations(projectRoot);
+    let projectSettingsPath;
+    if (input.enableProseFont) {
+        projectSettingsPath = writeProseEditorSettingsForProject(projectRoot);
+    }
+    return {
+        projectId,
+        projectPath: path.relative(input.workspace.repoRoot, projectRoot),
+        files: [
+            path.relative(input.workspace.repoRoot, projectJsonPath),
+            path.relative(input.workspace.repoRoot, projectPackagePath),
+            path.relative(input.workspace.repoRoot, starterManuscriptPath),
+            path.relative(input.workspace.repoRoot, charactersCategoryPath),
+            path.relative(input.workspace.repoRoot, charactersEntryPath),
+            path.relative(input.workspace.repoRoot, projectExtensionsPath),
+            ...(projectSettingsPath ? [path.relative(input.workspace.repoRoot, projectSettingsPath)] : [])
+        ]
+    };
+}
+export function parseProjectOutputFormat(raw) {
+    if (!raw || raw === "text") {
+        return "text";
+    }
+    if (raw === "json") {
+        return "json";
+    }
+    throw new CliError("INVALID_USAGE", "Invalid --format value. Use 'text' or 'json'.");
+}
+export function parseProseFontMode(raw) {
+    const normalized = (raw || "prompt").trim().toLowerCase();
+    if (normalized === "yes" || normalized === "true" || normalized === "y") {
+        return "yes";
+    }
+    if (normalized === "no" || normalized === "false" || normalized === "n") {
+        return "no";
+    }
+    if (normalized === "prompt" || normalized === "ask") {
+        return "prompt";
+    }
+    throw new CliError("INVALID_USAGE", "Invalid --prose-font value. Use 'yes', 'no', or 'prompt'.");
+}
+function ensureProjectExtensionsRecommendations(projectRoot) {
+    const vscodeDir = path.join(projectRoot, ".vscode");
+    const extensionsPath = path.join(vscodeDir, "extensions.json");
+    ensureDirectory(vscodeDir);
+    let existingRecommendations = [];
+    if (pathExists(extensionsPath)) {
+        try {
+            const parsed = JSON.parse(fs.readFileSync(extensionsPath, "utf8"));
+            if (Array.isArray(parsed.recommendations)) {
+                existingRecommendations = parsed.recommendations.filter((value) => typeof value === "string");
+            }
+        }
+        catch {
+            existingRecommendations = [];
+        }
+    }
+    const mergedRecommendations = [
+        ...new Set([...PROJECT_EXTENSION_RECOMMENDATIONS, ...existingRecommendations])
+    ];
+    writeTextFile(extensionsPath, `${JSON.stringify({ recommendations: mergedRecommendations }, null, 2)}\n`);
+    return extensionsPath;
+}
+function writeProseEditorSettingsForProject(projectRoot) {
+    const vscodeDir = path.join(projectRoot, ".vscode");
+    const settingsPath = path.join(vscodeDir, "settings.json");
+    ensureDirectory(vscodeDir);
+    let existingSettings = {};
+    if (pathExists(settingsPath)) {
+        try {
+            const parsed = JSON.parse(fs.readFileSync(settingsPath, "utf8"));
+            if (isPlainObject(parsed)) {
+                existingSettings = parsed;
+            }
+        }
+        catch {
+            existingSettings = {};
+        }
+    }
+    const proseMarkdownSettings = isPlainObject(PROSE_MARKDOWN_EDITOR_SETTINGS["[markdown]"])
+        ? PROSE_MARKDOWN_EDITOR_SETTINGS["[markdown]"]
+        : {};
+    const existingMarkdownSettings = isPlainObject(existingSettings["[markdown]"])
+        ? existingSettings["[markdown]"]
+        : {};
+    const nextSettings = {
+        ...existingSettings,
+        "[markdown]": {
+            ...existingMarkdownSettings,
+            ...proseMarkdownSettings
+        },
+        "markdown.preview.fontFamily": PROSE_MARKDOWN_EDITOR_SETTINGS["markdown.preview.fontFamily"]
+    };
+    writeTextFile(settingsPath, `${JSON.stringify(nextSettings, null, 2)}\n`);
+    return settingsPath;
+}
+function toDisplayTitle(value) {
+    return value
+        .split(/[-_]+/)
+        .filter(Boolean)
+        .map((part) => part.charAt(0).toUpperCase() + part.slice(1))
+        .join(" ");
+}
+function isPlainObject(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}

package/dist/stego-cli/src/modules/project/application/infer-project.js

@@ -0,0 +1,72 @@
+import fs from "node:fs";
+import path from "node:path";
+import { CliError } from "../../../../../shared/src/contracts/cli/index.js";
+import { listProjectIds, readJsonFile } from "../infra/project-repo.js";
+export function resolveProjectContext(input) {
+    const projectIds = listProjectIds(input.workspace);
+    const projectId = resolveProjectIdCandidate(input, projectIds);
+    if (!projectId) {
+        throw new CliError("PROJECT_NOT_FOUND", "Project id is required. Use --project <project-id>.");
+    }
+    const projectRoot = path.join(input.workspace.repoRoot, input.workspace.config.projectsDir, projectId);
+    const projectJsonPath = path.join(projectRoot, "stego-project.json");
+    if (!pathExists(projectRoot) || !pathExists(projectJsonPath)) {
+        throw new CliError("PROJECT_NOT_FOUND", `Project not found: ${projectRoot}`);
+    }
+    let meta;
+    try {
+        meta = readJsonFile(projectJsonPath);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw new CliError("INVALID_CONFIGURATION", `Invalid JSON at ${projectJsonPath}: ${message}`);
+    }
+    return {
+        id: projectId,
+        root: projectRoot,
+        manuscriptDir: path.join(projectRoot, input.workspace.config.chapterDir),
+        spineDir: path.join(projectRoot, input.workspace.config.spineDir),
+        notesDir: path.join(projectRoot, input.workspace.config.notesDir),
+        distDir: path.join(projectRoot, input.workspace.config.distDir),
+        meta,
+        workspace: input.workspace
+    };
+}
+function resolveProjectIdCandidate(input, ids) {
+    if (input.explicitProjectId) {
+        return input.explicitProjectId;
+    }
+    const fromEnv = readEnvProjectId(input.env);
+    if (fromEnv) {
+        return fromEnv;
+    }
+    const inferredFromCwd = inferProjectIdFromCwd(input.cwd, input.workspace);
+    if (inferredFromCwd) {
+        return inferredFromCwd;
+    }
+    return ids.length === 1 ? ids[0] : null;
+}
+function readEnvProjectId(env) {
+    const value = env.STEGO_PROJECT || env.WRITING_PROJECT;
+    if (!value) {
+        return null;
+    }
+    const normalized = value.trim();
+    return normalized.length > 0 ? normalized : null;
+}
+function inferProjectIdFromCwd(cwd, workspace) {
+    const projectsRoot = path.resolve(workspace.repoRoot, workspace.config.projectsDir);
+    const relative = path.relative(projectsRoot, path.resolve(cwd));
+    if (!relative || relative === "." || relative.startsWith("..") || path.isAbsolute(relative)) {
+        return null;
+    }
+    const projectId = relative.split(path.sep)[0];
+    if (!projectId) {
+        return null;
+    }
+    const projectJsonPath = path.join(projectsRoot, projectId, "stego-project.json");
+    return pathExists(projectJsonPath) ? projectId : null;
+}
+function pathExists(filePath) {
+    return Boolean(filePath) && fs.existsSync(filePath);
+}