@interf/compiler 0.6.1 → 0.6.4

package/dist/packages/compiler/validate.js

@@ -0,0 +1,249 @@
+import { existsSync, readFileSync, statSync, } from "node:fs";
+import { basename, extname, join } from "node:path";
+import { readCompiledSchemaFile } from "./compiled-schema.js";
+import { compiledKnowledgeRootPath } from "./compiled-schema.js";
+import { workflowPackagePathForCompiled } from "./compiled-paths.js";
+import { listFilesRecursive } from "../shared/filesystem.js";
+import { readInterfConfig } from "../project-model/interf-detect.js";
+import { parseJsonFrontmatter } from "../shared/parse.js";
+import { compiledInterfConfigPath } from "./compiled-paths.js";
+const MIN_ABSTRACT_WORDS = 5;
+const WIKILINK_PATTERN = /!?\[\[([^[\]]+)\]\]/g;
+export function readCompiledConfig(dirPath) {
+    const configPath = compiledInterfConfigPath(dirPath);
+    const value = readInterfConfig(dirPath);
+    const present = existsSync(configPath);
+    if (!present) {
+        return {
+            present: false,
+            valid: false,
+            value: null,
+            typeMatch: () => false,
+        };
+    }
+    return {
+        present: true,
+        valid: value !== null,
+        value,
+        typeMatch() {
+            return value?.type === "compiled" && typeof value?.source?.path === "string";
+        },
+    };
+}
+export function validateSynthFiles(files, options) {
+    let invalidFrontmatter = 0;
+    let shortAbstracts = 0;
+    for (const filePath of files) {
+        const content = safeReadText(filePath);
+        if (content === null)
+            continue;
+        const parsed = parseJsonFrontmatter(content);
+        if (!parsed || !hasRequiredFrontmatterKeys(parsed.frontmatter, options?.requiredFrontmatterKeys)) {
+            invalidFrontmatter += 1;
+            continue;
+        }
+        const abstractWords = countSynthAbstractWords(parsed.frontmatter, parsed.body);
+        if (abstractWords < MIN_ABSTRACT_WORDS) {
+            shortAbstracts += 1;
+        }
+    }
+    return {
+        invalid_frontmatter: invalidFrontmatter,
+        short_abstracts: shortAbstracts,
+    };
+}
+export function countBrokenWikilinks(compiledRoot, noteIndexRoots, linkScanRoots) {
+    const zonePathById = compiledZoneDirectoryPaths(compiledRoot);
+    const knowledgeRelativePrefixes = compiledKnowledgeRelativePrefixes(zonePathById);
+    const noteIndex = new Set();
+    for (const filePath of dedupeFiles(noteIndexRoots)) {
+        for (const target of collectWikilinkTargets(filePath)) {
+            noteIndex.add(target.toLowerCase());
+        }
+    }
+    let brokenLinks = 0;
+    for (const filePath of dedupeFiles(linkScanRoots)) {
+        const content = safeReadText(filePath);
+        if (content === null)
+            continue;
+        const matches = content.matchAll(WIKILINK_PATTERN);
+        for (const match of matches) {
+            const rawTarget = match[1]?.trim();
+            if (!rawTarget)
+                continue;
+            const target = rawTarget.split("|")[0]?.split("#")[0]?.trim();
+            if (!target)
+                continue;
+            if (target.includes("/")) {
+                if (!wikilinkPathExists(compiledRoot, target, zonePathById, knowledgeRelativePrefixes)) {
+                    brokenLinks += 1;
+                }
+                continue;
+            }
+            if (!noteIndex.has(target.toLowerCase()) &&
+                !noteIndex.has(noteName(target).toLowerCase()) &&
+                !wikilinkPathExists(compiledRoot, target, zonePathById, knowledgeRelativePrefixes) &&
+                !wikilinkPathExists(compiledRoot, noteName(target), zonePathById, knowledgeRelativePrefixes)) {
+                brokenLinks += 1;
+            }
+        }
+    }
+    return brokenLinks;
+}
+export function asNumber(value) {
+    return typeof value === "number" && Number.isFinite(value) ? value : 0;
+}
+export function isOutputMarkdownFile(filePath) {
+    return extname(filePath) === ".md" && basename(filePath) !== "AGENTS.md";
+}
+export function safeReadText(filePath) {
+    try {
+        return readFileSync(filePath, "utf-8");
+    }
+    catch {
+        return null;
+    }
+}
+function dedupeFiles(dirPaths) {
+    const seen = new Set();
+    const files = [];
+    for (const dirPath of dirPaths) {
+        if (existsSync(dirPath)) {
+            try {
+                const stat = statSync(dirPath);
+                if (stat.isFile()) {
+                    if (!seen.has(dirPath) && isOutputMarkdownFile(dirPath)) {
+                        seen.add(dirPath);
+                        files.push(dirPath);
+                    }
+                    continue;
+                }
+            }
+            catch {
+                continue;
+            }
+        }
+        for (const filePath of listFilesRecursive(dirPath, isOutputMarkdownFile)) {
+            if (seen.has(filePath))
+                continue;
+            seen.add(filePath);
+            files.push(filePath);
+        }
+    }
+    return files;
+}
+function hasRequiredFrontmatterKeys(frontmatter, requiredKeys) {
+    return (requiredKeys ?? []).every((field) => field in frontmatter);
+}
+function extractBodyAbstract(body) {
+    const lines = body.split(/\r?\n/);
+    const abstractHeadingIndex = lines.findIndex((line) => /^#{1,2}\s+Abstract\s*$/.test(line.trim()));
+    if (abstractHeadingIndex < 0)
+        return null;
+    const abstractLines = [];
+    for (let index = abstractHeadingIndex + 1; index < lines.length; index += 1) {
+        const line = lines[index] ?? "";
+        if (/^#{1,2}\s+\S/.test(line.trim()))
+            break;
+        abstractLines.push(line);
+    }
+    const abstractText = abstractLines.join("\n").trim();
+    return abstractText.length > 0 ? abstractText : null;
+}
+export function extractSynthAbstract(frontmatter, body) {
+    const frontmatterAbstract = typeof frontmatter.abstract === "string" ? frontmatter.abstract.trim() : "";
+    if (frontmatterAbstract.length > 0) {
+        return frontmatterAbstract;
+    }
+    return extractBodyAbstract(body);
+}
+export function countSynthAbstractWords(frontmatter, body) {
+    const abstract = extractSynthAbstract(frontmatter, body);
+    if (!abstract)
+        return 0;
+    return countWords(abstract);
+}
+function countWords(text) {
+    return text
+        .split(/\s+/)
+        .map((word) => word.trim())
+        .filter((word) => /[A-Za-z0-9]/.test(word)).length;
+}
+function noteName(filePath) {
+    return basename(filePath, extname(filePath));
+}
+function wikilinkPathExists(compiledRoot, target, zonePathById, knowledgeRelativePrefixes) {
+    return linkPathCandidates(compiledRoot, target, zonePathById, knowledgeRelativePrefixes)
+        .some((candidate) => existsSync(candidate));
+}
+function linkPathCandidates(compiledRoot, target, zonePathById, knowledgeRelativePrefixes) {
+    const candidates = new Set();
+    addPathCandidate(candidates, join(compiledRoot, target));
+    const [firstSegment] = target.split("/");
+    if (firstSegment && knowledgeRelativePrefixes.has(firstSegment)) {
+        addPathCandidate(candidates, join(compiledKnowledgeRootPath(compiledRoot), target));
+    }
+    if (firstSegment) {
+        const normalizedPrefix = zonePathById.get(firstSegment);
+        if (normalizedPrefix) {
+            const remainder = target.slice(firstSegment.length).replace(/^\/+/, "");
+            addPathCandidate(candidates, join(compiledRoot, normalizedPrefix, remainder));
+        }
+    }
+    return Array.from(candidates);
+}
+function addPathCandidate(candidates, absolutePath) {
+    candidates.add(absolutePath);
+    if (!absolutePath.endsWith(".md")) {
+        candidates.add(`${absolutePath}.md`);
+    }
+}
+function compiledZoneDirectoryPaths(compiledRoot) {
+    const workflowRoot = workflowPackagePathForCompiled(compiledRoot);
+    const schema = readCompiledSchemaFile(workflowRoot);
+    if (!schema)
+        return new Map();
+    return new Map(schema.zones
+        .filter((zone) => zone.kind === "directory")
+        .map((zone) => [zone.id, zone.path]));
+}
+function compiledKnowledgeRelativePrefixes(zonePathById) {
+    const prefixes = new Set();
+    for (const zonePath of zonePathById.values()) {
+        const [root, leaf, ...rest] = zonePath.split("/");
+        if (root !== "knowledge" || !leaf || rest.length > 0)
+            continue;
+        prefixes.add(leaf);
+    }
+    return prefixes;
+}
+function collectWikilinkTargets(filePath) {
+    const targets = new Set();
+    targets.add(noteName(filePath));
+    const content = safeReadText(filePath);
+    if (content === null)
+        return Array.from(targets);
+    const parsed = parseJsonFrontmatter(content);
+    const frontmatter = parsed?.frontmatter;
+    if (!frontmatter)
+        return Array.from(targets);
+    addFrontmatterLinkTarget(targets, frontmatter.label);
+    addFrontmatterLinkTarget(targets, frontmatter.title);
+    addFrontmatterLinkTarget(targets, frontmatter.alias);
+    addFrontmatterLinkTarget(targets, frontmatter.aliases);
+    return Array.from(targets);
+}
+function addFrontmatterLinkTarget(targets, value) {
+    if (typeof value === "string") {
+        const trimmed = value.trim();
+        if (trimmed.length > 0)
+            targets.add(trimmed);
+        return;
+    }
+    if (Array.isArray(value)) {
+        for (const entry of value) {
+            addFrontmatterLinkTarget(targets, entry);
+        }
+    }
+}
+export { validateCompiled, validateCompiledStage, validateCompiledWorkflow, validateCompiledSummarize, validateCompiledStructure, validateCompiledCompile, } from "./validate-compiled.js";

package/dist/packages/compiler/workflow-primitives.d.ts

@@ -0,0 +1,2 @@
+export declare const COMPILED_ZONE_KINDS: readonly ["directory", "file", "runtime"];
+export type CompiledZoneKind = typeof COMPILED_ZONE_KINDS[number];

package/dist/packages/compiler/workflow-primitives.js

@@ -0,0 +1,5 @@
+export const COMPILED_ZONE_KINDS = [
+    "directory",
+    "file",
+    "runtime",
+];

package/dist/packages/compiler/workflows.d.ts

@@ -0,0 +1,15 @@
+import { type InterfConfig } from "../project-model/interf-detect.js";
+export type { WorkflowReporter, WorkflowStageResult, LocalSkillContractExtension } from "../workflow-package/workflow-helpers.js";
+export { workflowQueryDirectory, workflowImproveDirectory, workflowCompileStageDirectory, emptyLocalSkillContractExtension, buildLocalSkillContractExtension, buildLocalSkillContractExtensionRelativeTo, mergeLocalSkillContractExtensions, buildStageInstructions, reportLine, reportBlankLine, reportValidationFailure, resolveStageAcceptance, validateStageOutcome, } from "../workflow-package/workflow-helpers.js";
+export type CompiledCheck = "compiled" | "stage";
+export interface DetectedInterfTarget {
+    path: string;
+    kind: "compiled";
+    engineType: "compiled";
+    config: InterfConfig;
+}
+export declare function detectCompiled(cwd: string): DetectedInterfTarget | null;
+export declare function createCompiled(name: string, sourcePath: string, workflowId?: string, about?: string, datasetPath?: string): string;
+export declare function verifyCompiledCheck(check: CompiledCheck, compiledPath: string): import("./validate-compiled.js").CompiledWorkflowValidation;
+export { runCompiledSummarize, runCompiledCompile, compileCompiled, resolveCompiledContext, compiledExecutionStages, } from "./compiled-compile.js";
+export type { CompiledSummarizeResult, CompiledCompileResult, CompiledStageExecutionDefinition, StageShellRetentionMode, } from "./compiled-compile.js";

package/dist/packages/compiler/workflows.js

@@ -0,0 +1,31 @@
+import { createCompiled as createCompiledScaffold, } from "../project-model/interf-scaffold.js";
+import { detectInterf } from "../project-model/interf-detect.js";
+import { validateCompiledCompile, } from "./validate.js";
+export { workflowQueryDirectory, workflowImproveDirectory, workflowCompileStageDirectory, emptyLocalSkillContractExtension, buildLocalSkillContractExtension, buildLocalSkillContractExtensionRelativeTo, mergeLocalSkillContractExtensions, buildStageInstructions, reportLine, reportBlankLine, reportValidationFailure, resolveStageAcceptance, validateStageOutcome, } from "../workflow-package/workflow-helpers.js";
+export function detectCompiled(cwd) {
+    const detected = detectInterf(cwd);
+    if (!detected)
+        return null;
+    return {
+        path: detected.path,
+        kind: "compiled",
+        engineType: "compiled",
+        config: detected.config,
+    };
+}
+export function createCompiled(name, sourcePath, workflowId = "interf", about, datasetPath = sourcePath) {
+    return createCompiledScaffold(name, sourcePath, workflowId, about, datasetPath);
+}
+export function verifyCompiledCheck(check, compiledPath) {
+    switch (check) {
+        case "compiled":
+            return validateCompiledCompile(compiledPath);
+        case "stage":
+            return validateCompiledCompile(compiledPath);
+        default: {
+            const exhaustiveCheck = check;
+            throw new Error(`Unknown compiled check: ${exhaustiveCheck}`);
+        }
+    }
+}
+export { runCompiledSummarize, runCompiledCompile, compileCompiled, resolveCompiledContext, compiledExecutionStages, } from "./compiled-compile.js";

package/dist/packages/project-model/compiled-paths.d.ts

@@ -0,0 +1 @@
+export * from "../compiler/compiled-paths.js";

package/dist/packages/project-model/compiled-paths.js

@@ -0,0 +1 @@
+export * from "../compiler/compiled-paths.js";

package/dist/packages/project-model/compiled-raw.d.ts

@@ -0,0 +1 @@
+export * from "../compiler/raw-snapshot.js";

package/dist/packages/project-model/compiled-raw.js

@@ -0,0 +1 @@
+export * from "../compiler/raw-snapshot.js";

package/dist/packages/project-model/compiled-reset.d.ts

@@ -0,0 +1 @@
+export * from "../compiler/reset.js";

package/dist/packages/project-model/compiled-reset.js

@@ -0,0 +1 @@
+export * from "../compiler/reset.js";

package/dist/packages/project-model/index.d.ts

@@ -0,0 +1,11 @@
+export * as schema from "./lib/schema.js";
+export * as sourceConfig from "./source-config.js";
+export * as interf from "./interf.js";
+export * as detect from "./interf-detect.js";
+export * as bootstrap from "./interf-bootstrap.js";
+export * as scaffold from "./interf-scaffold.js";
+export * as compiledPaths from "./compiled-paths.js";
+export * as projectPaths from "./project-paths.js";
+export * as compiledRaw from "./compiled-raw.js";
+export * as compiledReset from "./compiled-reset.js";
+export type { InterfConfig, SourceDatasetConfig, SourceFolderConfig, SourceTruthCheck, } from "./lib/schema.js";

package/dist/packages/project-model/index.js

@@ -0,0 +1,10 @@
+export * as schema from "./lib/schema.js";
+export * as sourceConfig from "./source-config.js";
+export * as interf from "./interf.js";
+export * as detect from "./interf-detect.js";
+export * as bootstrap from "./interf-bootstrap.js";
+export * as scaffold from "./interf-scaffold.js";
+export * as compiledPaths from "./compiled-paths.js";
+export * as projectPaths from "./project-paths.js";
+export * as compiledRaw from "./compiled-raw.js";
+export * as compiledReset from "./compiled-reset.js";

package/dist/packages/project-model/interf-bootstrap.d.ts

@@ -0,0 +1 @@
+export { refreshCompiledBootstrapGuidance, renderClaudeBootstrap, } from "../agents/lib/compiled-bootstrap.js";

package/dist/packages/project-model/interf-bootstrap.js

@@ -0,0 +1 @@
+export { refreshCompiledBootstrapGuidance, renderClaudeBootstrap, } from "../agents/lib/compiled-bootstrap.js";

package/dist/packages/project-model/interf-detect.d.ts

@@ -0,0 +1,33 @@
+import { type InterfConfig } from "./lib/schema.js";
+export type { InterfConfig } from "./lib/schema.js";
+export interface ResolvedCompiled {
+    sourcePath: string;
+    compiledPath: string;
+    config: InterfConfig;
+}
+export declare const INTERF_CONTAINER_NAME = "interf";
+export declare const WORKFLOW_CONTAINER_NAME = "workflows";
+export declare const TEST_CONTAINER_NAME = "tests";
+export declare const INTERF_CONFIG_FILE = "interf.json";
+export declare const WORKFLOW_PACKAGE_DIR = "workflow";
+export declare function readInterfConfig(dirPath: string): InterfConfig | null;
+export declare function hasSourceFolderInput(config: InterfConfig | null | undefined): config is InterfConfig & {
+    source: {
+        path: string;
+    };
+};
+export declare function detectInterf(cwd: string): {
+    path: string;
+    config: InterfConfig;
+} | null;
+export declare function resolveCompiled(cwd: string): ResolvedCompiled | null;
+export declare function resolveSourceFolderPath(compiledPath: string, config?: InterfConfig | null): string;
+export declare function resolveSourceControlPath(compiledPath: string): string;
+export declare function resolveSourceInputPath(compiledPath: string): string;
+export declare function listCompiledDatasetsForSourceFolder(sourcePath: string): Array<{
+    path: string;
+    config: InterfConfig;
+}>;
+export declare function assertCompiledContainer(sourcePath: string): string;
+export declare function assertWritableTargetDir(dirPath: string, label: string): void;
+export declare function assertCompiledName(name: string, label: string): void;

package/dist/packages/project-model/interf-detect.js

@@ -0,0 +1,176 @@
+import { existsSync, readdirSync, statSync, } from "node:fs";
+import { join, resolve } from "node:path";
+import { warnInterf } from "../shared/logger.js";
+import { readJsonFileUnchecked } from "../shared/parse.js";
+import { compiledCompiledPathForDataset, projectInterfRoot, } from "./project-paths.js";
+import { resolveSourceControlPathForCompiled, compiledInterfConfigPath, } from "../compiler/compiled-paths.js";
+import { InterfConfigSchema, } from "./lib/schema.js";
+import { assertPathWithinRoot } from "../shared/path-guards.js";
+export const INTERF_CONTAINER_NAME = "interf";
+export const WORKFLOW_CONTAINER_NAME = "workflows";
+export const TEST_CONTAINER_NAME = "tests";
+export const INTERF_CONFIG_FILE = "interf.json";
+export const WORKFLOW_PACKAGE_DIR = "workflow";
+export function readInterfConfig(dirPath) {
+    const configPath = compiledInterfConfigPath(dirPath);
+    if (!existsSync(configPath))
+        return null;
+    const raw = readJsonFileUnchecked(configPath, "Interf config");
+    if (raw === null)
+        return null;
+    if (!raw || typeof raw !== "object" || Array.isArray(raw))
+        return null;
+    if (raw.type !== "compiled") {
+        return null;
+    }
+    const parsed = InterfConfigSchema.safeParse(raw);
+    if (!parsed.success) {
+        warnInterf(`Warning: failed to validate Interf config at ${configPath}: ${parsed.error.issues.map((issue) => issue.message).join("; ")}`);
+        return null;
+    }
+    return parsed.data;
+}
+export function hasSourceFolderInput(config) {
+    return typeof config?.source?.path === "string" && config.source.path.length > 0;
+}
+export function detectInterf(cwd) {
+    const config = readInterfConfig(cwd);
+    if (config)
+        return { path: cwd, config };
+    return null;
+}
+export function resolveCompiled(cwd) {
+    const detected = detectInterf(cwd);
+    if (!detected)
+        return null;
+    return {
+        sourcePath: resolveSourceControlPath(detected.path),
+        compiledPath: detected.path,
+        config: detected.config,
+    };
+}
+export function resolveSourceFolderPath(compiledPath, config = null) {
+    const resolvedConfig = config ?? readInterfConfig(compiledPath);
+    if (hasSourceFolderInput(resolvedConfig)) {
+        return assertPathWithinRoot(compiledPath, resolve(compiledPath, resolvedConfig.source.path), "Compiled raw source path");
+    }
+    return resolve(compiledPath, "raw");
+}
+export function resolveSourceControlPath(compiledPath) {
+    return resolveSourceControlPathForCompiled(compiledPath);
+}
+export function resolveSourceInputPath(compiledPath) {
+    const config = readInterfConfig(compiledPath);
+    if (typeof config?.source?.dataset_path === "string" && config.source.dataset_path.length > 0) {
+        const projectPath = resolveSourceControlPathForCompiled(compiledPath);
+        return assertPathWithinRoot(projectPath, resolve(compiledPath, config.source.dataset_path), "Dataset source path");
+    }
+    throw new Error(`Context folder is missing source.dataset_path in ${compiledInterfConfigPath(compiledPath)}.`);
+}
+export function listCompiledDatasetsForSourceFolder(sourcePath) {
+    const interfRoot = projectInterfRoot(sourcePath);
+    if (!existsSync(interfRoot))
+        return [];
+    try {
+        if (!statSync(interfRoot).isDirectory())
+            return [];
+    }
+    catch (error) {
+        warnInterf(`Warning: failed to inspect Interf container at ${interfRoot}: ${error instanceof Error ? error.message : String(error)}`);
+        return [];
+    }
+    return readdirSync(interfRoot)
+        .filter((entry) => !entry.startsWith(".") &&
+        entry !== WORKFLOW_CONTAINER_NAME &&
+        entry !== TEST_CONTAINER_NAME)
+        .map((entry) => compiledCompiledPathForDataset(sourcePath, entry))
+        .filter((compiledPath) => existsSync(compiledPath))
+        .map((compiledPath) => {
+        const config = readInterfConfig(compiledPath);
+        return config ? { path: compiledPath, config } : null;
+    })
+        .filter((value) => value !== null);
+}
+export function assertCompiledContainer(sourcePath) {
+    const interfRoot = projectInterfRoot(sourcePath);
+    if (existsSync(interfRoot)) {
+        const stat = statSync(interfRoot);
+        if (!stat.isDirectory()) {
+            throw new Error(`Interf container exists and is not a directory: ${interfRoot}`);
+        }
+        const unexpectedRootEntries = readdirSync(interfRoot).filter((entry) => {
+            if (entry.startsWith("."))
+                return false;
+            const entryPath = join(interfRoot, entry);
+            if (entry === WORKFLOW_CONTAINER_NAME || entry === TEST_CONTAINER_NAME) {
+                try {
+                    return !statSync(entryPath).isDirectory();
+                }
+                catch (error) {
+                    warnInterf(`Warning: failed to inspect Interf control-plane path at ${entryPath}: ${error instanceof Error ? error.message : String(error)}`);
+                    return true;
+                }
+            }
+            try {
+                if (!statSync(entryPath).isDirectory())
+                    return true;
+            }
+            catch (error) {
+                warnInterf(`Warning: failed to inspect Interf entry at ${entryPath}: ${error instanceof Error ? error.message : String(error)}`);
+                return true;
+            }
+            return false;
+        });
+        if (unexpectedRootEntries.length > 0) {
+            throw new Error(`Interf container contains unexpected entries: ${interfRoot}`);
+        }
+    }
+    const containerPath = interfRoot;
+    if (!existsSync(containerPath)) {
+        return containerPath;
+    }
+    const stat = statSync(containerPath);
+    if (!stat.isDirectory()) {
+        throw new Error(`Interf container exists and is not a directory: ${containerPath}`);
+    }
+    const unexpectedEntries = readdirSync(containerPath).filter((entry) => {
+        if (entry.startsWith("."))
+            return false;
+        if (entry === WORKFLOW_CONTAINER_NAME || entry === TEST_CONTAINER_NAME)
+            return false;
+        const entryPath = join(containerPath, entry);
+        try {
+            if (!statSync(entryPath).isDirectory())
+                return true;
+        }
+        catch (error) {
+            warnInterf(`Warning: failed to inspect Interf entry at ${entryPath}: ${error instanceof Error ? error.message : String(error)}`);
+            return true;
+        }
+        const compiledPath = compiledCompiledPathForDataset(sourcePath, entry);
+        if (!existsSync(compiledPath)) {
+            return false;
+        }
+        return !readInterfConfig(compiledPath);
+    });
+    if (unexpectedEntries.length > 0) {
+        throw new Error(`Interf container contains invalid dataset entries: ${containerPath}`);
+    }
+    return containerPath;
+}
+export function assertWritableTargetDir(dirPath, label) {
+    if (!existsSync(dirPath))
+        return;
+    const stat = statSync(dirPath);
+    if (!stat.isDirectory()) {
+        throw new Error(`${label} target exists and is not a directory: ${dirPath}`);
+    }
+    if (readdirSync(dirPath).length > 0) {
+        throw new Error(`${label} target already exists and is not empty: ${dirPath}`);
+    }
+}
+export function assertCompiledName(name, label) {
+    if (!/^[a-z0-9][a-z0-9-]*$/.test(name)) {
+        throw new Error(`${label} name must be a safe slug with lowercase letters, numbers, and dashes only: ${name}`);
+    }
+}

package/dist/packages/project-model/interf-scaffold.d.ts

@@ -0,0 +1,2 @@
+export declare function createCompiled(name: string, sourcePath: string, workflowId?: string, about?: string, datasetPath?: string): string;
+export declare function defaultCompiledNameForSource(sourcePath: string): string;