@vimhead.dev/norn-cli 0.1.0-tip.35359392805.1 → 0.1.0-tip.35436871363.1

package/assets/packages/cli/src/plugin-loader.ts

@@ -1,400 +0,0 @@
-import * as nornModule from "@vimhead.dev/norn";
-import { isWorkflowPlugin, type NornDispose, type NornPluginDiagnostic, type NornProjectInfo, type NornProjectInspection, type NornProjectPluginInfo, type NornWorkflowCatalogInfo, type NornWorkflowInspection, type NornWorkflowPlugin, type NornWorkflowPluginInfo } from "@vimhead.dev/norn";
-import { isNodeError } from "@vimhead.dev/norn-core/errors";
-import * as nornFilesModule from "@vimhead.dev/norn/files";
-import * as nornSchemaModule from "@vimhead.dev/norn/schema";
-import { inspectSchema } from "@vimhead.dev/norn/schema";
-import { createJiti } from "jiti/static";
-import { access, readdir, readFile } from "node:fs/promises";
-import { dirname, isAbsolute, join, resolve, sep } from "node:path";
-import { pathToFileURL } from "node:url";
-import * as typeboxModule from "typebox";
-import { Type, type StaticDecode } from "typebox";
-import * as typeboxCompileModule from "typebox/compile";
-import * as typeboxSchemaModule from "typebox/schema";
-import * as typeboxValueModule from "typebox/value";
-import { AssertError, Value } from "typebox/value";
-import { errorMessage, NornProjectLoadError } from "./internal/errors.ts";
-import { NornMemoryWorkflowState } from "./internal/state-store.ts";
-import { decodePluginConfiguration, NornWorkflowRegistry, type NornRegisteredWorkflow } from "./internal/workflow-registry.ts";
-
-export const NORN_PROJECT_FILE_NAME = "norn.project.json";
-
-const nornConfigSchema = Type.Object({
-	plugins: Type.Array(Type.String({ minLength: 1 }), { default: [] }),
-	includes: Type.Array(Type.String({ minLength: 1 }), { default: [] }),
-	config: Type.Record(Type.String(), Type.Unknown(), { default: {} }),
-});
-const nornProjectConfigSchema = Type.Object({
-	...nornConfigSchema.properties,
-	version: Type.Literal(1, { default: 1 }),
-});
-
-type NornConfig = StaticDecode<typeof nornConfigSchema>;
-type NornProjectConfig = StaticDecode<typeof nornProjectConfigSchema>;
-
-type NornConfigFile = {
-	readonly path: string;
-	readonly root: string;
-	readonly config: NornConfig;
-};
-
-export type NornProject = {
-	readonly cwd: string;
-	readonly projectPath: string;
-	readonly projectRoot: string;
-	readonly configPath: string;
-	readonly configRoot: string;
-	readonly config: NornProjectConfig;
-	readonly configFiles: readonly NornConfigFile[];
-	readonly projectConfig: Record<string, unknown>;
-};
-
-export type NornLoadedProject = NornProject & {
-	readonly plugins: readonly NornWorkflowPlugin[];
-	readonly pluginInfos: readonly NornProjectPluginInfo[];
-	readonly registry: NornWorkflowRegistry;
-	readonly workflows: readonly NornRegisteredWorkflow[];
-	readonly state: NornMemoryWorkflowState;
-};
-
-type LoadedNornWorkflowPlugin = {
-	readonly plugin: NornWorkflowPlugin;
-	readonly info: NornProjectPluginInfo;
-};
-
-export async function loadNornProject(cwd: string): Promise<NornLoadedProject> {
-	const { project, diagnostics } = await collectNornProject(cwd);
-	if (diagnostics.length > 0) throw new NornProjectLoadError({ diagnostics });
-	return project;
-}
-
-export async function discoverNornProject(cwd: string): Promise<NornProjectInspection & NornWorkflowCatalogInfo> {
-	const { project, diagnostics } = await collectNornProject(cwd);
-	return { project: buildProjectInfo(project), workflows: project.registry.list(), isComplete: diagnostics.length === 0, diagnostics };
-}
-
-export async function inspectNornWorkflow(input: { readonly cwd: string; readonly workflowId: string }): Promise<NornWorkflowInspection> {
-	const { project, diagnostics } = await collectNornProject(input.cwd);
-	const summary = project.registry.list().find(workflow => workflow.id === input.workflowId);
-	if (!summary) {
-		if (diagnostics.length === 0) throw new Error(`Unknown workflow: ${input.workflowId}`);
-		return { workflow: null, isComplete: false, diagnostics };
-	}
-	const info = summary.plugin;
-	if (!info?.path || !info.configPath) throw new Error(`Loaded workflow lacks plugin source: ${input.workflowId}`);
-	try {
-		return { workflow: project.registry.inspect(input.workflowId) ?? null, isComplete: diagnostics.length === 0, diagnostics };
-	} catch (error) {
-		return { workflow: null, isComplete: false, diagnostics: [...diagnostics, createPluginDiagnostic({
-			source: { configPath: info.configPath, pluginPath: info.path, pluginId: info.id },
-			workflowId: input.workflowId, stage: "schema", error,
-		})] };
-	}
-}
-
-function buildProjectInfo(project: NornLoadedProject): NornProjectInfo {
-	return {
-		cwd: project.cwd, projectPath: project.projectPath, projectRoot: project.projectRoot,
-		configPath: project.configPath, configRoot: project.configRoot,
-		configFiles: project.configFiles.map(file => file.path), plugins: project.pluginInfos,
-	};
-}
-
-export async function findNornProject(cwd: string): Promise<NornProject> {
-	const projectPath = await findNearestNornProject(cwd);
-	const projectRootConfig = await readNornProjectConfigFile(projectPath);
-	const configFiles = await loadIncludedNornConfigFiles(projectRootConfig, new Set([projectRootConfig.path]));
-	return {
-		cwd: resolve(cwd),
-		projectPath: projectRootConfig.path,
-		projectRoot: projectRootConfig.root,
-		configPath: projectRootConfig.path,
-		configRoot: projectRootConfig.root,
-		config: projectRootConfig.config,
-		configFiles,
-		projectConfig: mergeProjectConfig(configFiles),
-	};
-}
-
-async function findNearestNornProject(cwd: string): Promise<string> {
-	let current = resolve(cwd);
-	while (true) {
-		const projectPath = join(current, NORN_PROJECT_FILE_NAME);
-		try {
-			await access(projectPath);
-			return projectPath;
-		} catch (error) {
-			if (!isNodeError(error) || error.code !== "ENOENT") throw error;
-		}
-		const parent = dirname(current);
-		if (parent === current) throw new Error(`Could not find ${NORN_PROJECT_FILE_NAME} from ${cwd}`);
-		current = parent;
-	}
-}
-
-type NornProjectConfigFile = {
-	readonly path: string;
-	readonly root: string;
-	readonly config: NornProjectConfig;
-};
-
-async function loadIncludedNornConfigFiles(projectFile: NornProjectConfigFile, visitedPaths: Set<string>): Promise<NornConfigFile[]> {
-	const includedConfigFiles = await Promise.all(projectFile.config.includes.map(async (includePath) => {
-		const configPaths = await expandIncludePath(projectFile.root, includePath);
-		return Promise.all(configPaths.map(readNornConfigFile));
-	}));
-	const descendants = await Promise.all(includedConfigFiles.flat().map((includedConfigFile) => loadNornConfigTree(includedConfigFile, visitedPaths)));
-	return [createProjectConfigEntry(projectFile), ...descendants.flat()];
-}
-
-async function loadNornConfigTree(configFile: NornConfigFile, visitedPaths: Set<string>): Promise<NornConfigFile[]> {
-	if (visitedPaths.has(configFile.path)) return [];
-	visitedPaths.add(configFile.path);
-	const includedConfigFiles = await Promise.all(configFile.config.includes.map(async (includePath) => {
-		const configPaths = await expandIncludePath(configFile.root, includePath);
-		return Promise.all(configPaths.map(readNornConfigFile));
-	}));
-	const descendants = await Promise.all(includedConfigFiles.flat().map((includedConfigFile) => loadNornConfigTree(includedConfigFile, visitedPaths)));
-	return [configFile, ...descendants.flat()];
-}
-
-async function readNornProjectConfigFile(path: string): Promise<NornProjectConfigFile> {
-	const config = Value.Parse(nornProjectConfigSchema, Value.Default(nornProjectConfigSchema, JSON.parse(await readFile(path, "utf8"))));
-	return { path, root: dirname(path), config };
-}
-
-async function readNornConfigFile(path: string): Promise<NornConfigFile> {
-	const config = Value.Parse(nornConfigSchema, Value.Default(nornConfigSchema, JSON.parse(await readFile(path, "utf8"))));
-	return { path, root: dirname(path), config };
-}
-
-function createProjectConfigEntry(projectFile: NornProjectConfigFile): NornConfigFile {
-	return {
-		path: projectFile.path,
-		root: projectFile.root,
-		config: {
-			plugins: projectFile.config.plugins,
-			includes: projectFile.config.includes,
-			config: projectFile.config.config,
-		},
-	};
-}
-
-type NornPluginSource = Pick<NornPluginDiagnostic, "configPath" | "pluginPath" | "pluginId">;
-type ImportedNornPlugin = { readonly plugin: NornWorkflowPlugin; readonly source: NornPluginSource };
-
-async function collectNornProject(cwd: string): Promise<{ readonly project: NornLoadedProject; readonly diagnostics: NornPluginDiagnostic[] }> {
-	const project = await findNornProject(cwd);
-	const imported = await importWorkflowPlugins(project);
-	const diagnostics = [...imported.diagnostics];
-	const registry = new NornWorkflowRegistry();
-	const state = new NornMemoryWorkflowState();
-	const loaded: LoadedNornWorkflowPlugin[] = [];
-	const conflicts = collectPluginConflicts(imported.plugins);
-	for (const candidate of imported.plugins) {
-		const pluginConflicts = conflicts.get(candidate);
-		if (pluginConflicts) {
-			diagnostics.push(...pluginConflicts);
-			continue;
-		}
-		const result = registerProjectPlugin({ candidate, project, registry, state });
-		diagnostics.push(...result.diagnostics);
-		if (result.loaded) loaded.push(result.loaded);
-	}
-	return {
-		project: { ...project, plugins: loaded.map(entry => entry.plugin), pluginInfos: loaded.map(entry => entry.info), registry, workflows: registry.launchableEntries(), state },
-		diagnostics,
-	};
-}
-
-function collectPluginConflicts(plugins: readonly ImportedNornPlugin[]): Map<ImportedNornPlugin, NornPluginDiagnostic[]> {
-	const byPluginId = new Map<string, ImportedNornPlugin[]>();
-	const byWorkflowId = new Map<string, ImportedNornPlugin[]>();
-	for (const candidate of plugins) {
-		const id = candidate.plugin.manifest.id;
-		byPluginId.set(id, [...(byPluginId.get(id) ?? []), candidate]);
-		for (const workflowId of new Set(Object.values(candidate.plugin.manifest.workflows).map(workflow => workflow.id))) {
-			byWorkflowId.set(workflowId, [...(byWorkflowId.get(workflowId) ?? []), candidate]);
-		}
-	}
-	const conflicts = new Map<ImportedNornPlugin, NornPluginDiagnostic[]>();
-	for (const [pluginId, candidates] of byPluginId) {
-		if (candidates.length < 2) continue;
-		for (const candidate of candidates) conflicts.set(candidate, [createPluginDiagnostic({
-			source: candidate.source, workflowId: null, stage: "duplicate",
-			error: new Error(`Duplicate Norn plugin id: ${pluginId} (${candidates.map(other => other.source.pluginPath).join(", ")})`),
-		})]);
-	}
-	for (const [workflowId, candidates] of byWorkflowId) {
-		const distinctPlugins = candidates.filter(candidate => byPluginId.get(candidate.plugin.manifest.id)?.length === 1);
-		if (distinctPlugins.length < 2) continue;
-		for (const candidate of distinctPlugins) conflicts.set(candidate, [...(conflicts.get(candidate) ?? []), createPluginDiagnostic({
-			source: candidate.source, workflowId, stage: "duplicate",
-			error: new Error(`Workflow already registered: ${workflowId} (${distinctPlugins.map(other => other.source.pluginPath).join(", ")})`),
-		})]);
-	}
-	return conflicts;
-}
-
-async function importWorkflowPlugins(project: NornProject): Promise<{ readonly plugins: ImportedNornPlugin[]; readonly diagnostics: NornPluginDiagnostic[] }> {
-	const plugins: ImportedNornPlugin[] = [];
-	const diagnostics: NornPluginDiagnostic[] = [];
-	for (const configFile of project.configFiles) {
-		const jiti = createJiti(pathToFileURL(configFile.path).href, { moduleCache: false, virtualModules: nornWorkflowVirtualModules() });
-		for (const pluginPath of configFile.config.plugins) {
-			const source: NornPluginSource = { configPath: configFile.path, pluginPath: resolveConfigPath(configFile.root, pluginPath), pluginId: null };
-			let stage: NornPluginDiagnostic["stage"] = "import";
-			try {
-				const module = await jiti.import(pathToFileURL(source.pluginPath).href) as { default?: unknown };
-				stage = "declaration";
-				if (!isWorkflowPlugin(module?.default)) throw new Error(`Norn plugin must be the default export: ${source.pluginPath}`);
-				plugins.push({ plugin: module.default, source: { ...source, pluginId: module.default.manifest.id } });
-			} catch (error) {
-				diagnostics.push(createPluginDiagnostic({ source, workflowId: null, stage, error }));
-			}
-		}
-	}
-	return { plugins, diagnostics };
-}
-
-function registerProjectPlugin(input: {
-	readonly candidate: ImportedNornPlugin;
-	readonly project: NornProject;
-	readonly registry: NornWorkflowRegistry;
-	readonly state: NornMemoryWorkflowState;
-}): { readonly loaded: LoadedNornWorkflowPlugin | null; readonly diagnostics: NornPluginDiagnostic[] } {
-	const { plugin, source } = input.candidate;
-	const diagnostics: NornPluginDiagnostic[] = [];
-	const unregister: NornDispose[] = [];
-	let stage: NornPluginDiagnostic["stage"] = "config";
-	try {
-		const configInput = input.project.projectConfig[plugin.manifest.id];
-		const configuration = decodePluginConfiguration({ pluginId: plugin.manifest.id, schema: plugin.manifest.config, value: configInput });
-		stage = "schema";
-		const info: NornProjectPluginInfo = {
-			id: plugin.manifest.id, path: source.pluginPath, configPath: source.configPath,
-			configSchema: plugin.manifest.config ? inspectSchema(plugin.manifest.config) : null, config: configuration?.value,
-		};
-		stage = "implementation";
-		const implementation = typeof plugin.implementation === "function" ? plugin.implementation({ cwd: input.project.cwd, state: input.state }) : plugin.implementation;
-		for (const [key, workflow] of Object.entries(plugin.manifest.workflows)) {
-			stage = "implementation";
-			try {
-				const workflowImplementation = implementation.workflows?.[key];
-				if (typeof workflowImplementation?.execute !== "function") throw new Error(`Missing implementation for workflow ${workflow.id}`);
-				stage = "duplicate";
-				if (input.registry.workflowById(workflow.id)) throw new Error(`Workflow already registered: ${workflow.id}`);
-				stage = "declaration";
-				unregister.push(input.registry.register(workflow, workflowImplementation, { plugin: workflowPluginInfo(info), configuration }));
-			} catch (error) {
-				diagnostics.push(createPluginDiagnostic({ source, workflowId: workflow.id, stage, error }));
-			}
-		}
-		if (diagnostics.length === 0) return { loaded: { plugin, info }, diagnostics };
-	} catch (error) {
-		diagnostics.push(createPluginDiagnostic({ source, workflowId: null, stage, error }));
-	}
-	for (const dispose of unregister) dispose();
-	return { loaded: null, diagnostics };
-}
-
-function createPluginDiagnostic(input: {
-	readonly source: NornPluginSource;
-	readonly workflowId: string | null;
-	readonly stage: NornPluginDiagnostic["stage"];
-	readonly error: unknown;
-}): NornPluginDiagnostic {
-	return {
-		...input.source, workflowId: input.workflowId, stage: input.stage, message: errorMessage(input.error),
-		issues: input.error instanceof AssertError ? input.error.cause.errors : [],
-	};
-}
-
-function workflowPluginInfo(info: NornProjectPluginInfo): NornWorkflowPluginInfo {
-	return { id: info.id, path: info.path, configPath: info.configPath };
-}
-
-function nornWorkflowVirtualModules(): Record<string, unknown> {
-	return {
-		"@vimhead.dev/norn": nornModule,
-		"@vimhead.dev/norn/files": nornFilesModule,
-		"@vimhead.dev/norn/schema": nornSchemaModule,
-		typebox: typeboxModule,
-		"typebox/value": typeboxValueModule,
-		"typebox/compile": typeboxCompileModule,
-		"typebox/schema": typeboxSchemaModule,
-	};
-}
-
-function mergeProjectConfig(configFiles: readonly NornConfigFile[]): Record<string, unknown> {
-	const [projectFile, ...reusableConfigFiles] = configFiles;
-	let reusableConfig: Record<string, unknown> = {};
-	for (const configFile of reusableConfigFiles) {
-		reusableConfig = mergeReusableConfigObjects(reusableConfig, configFile.config.config, ["config"]);
-	}
-	return mergeProjectConfigObjects(reusableConfig, projectFile?.config.config ?? {});
-}
-
-function mergeReusableConfigObjects(base: Record<string, unknown>, override: Record<string, unknown>, path: readonly string[]): Record<string, unknown> {
-	const result: Record<string, unknown> = { ...base };
-	for (const [key, overrideValue] of Object.entries(override)) {
-		result[key] = Object.prototype.hasOwnProperty.call(result, key)
-			? mergeReusableConfigValue(result[key], overrideValue, [...path, key])
-			: overrideValue;
-	}
-	return result;
-}
-
-function mergeReusableConfigValue(base: unknown, override: unknown, path: readonly string[]): unknown {
-	if (isPlainObject(base) && isPlainObject(override)) return mergeReusableConfigObjects(base, override, path);
-	if (JSON.stringify(base) === JSON.stringify(override)) return base;
-	throw new Error(`Conflicting Norn reusable config at ${path.join(".")}`);
-}
-
-function mergeProjectConfigObjects(base: Record<string, unknown>, override: Record<string, unknown>): Record<string, unknown> {
-	const result: Record<string, unknown> = { ...base };
-	for (const [key, overrideValue] of Object.entries(override)) {
-		result[key] = isPlainObject(result[key]) && isPlainObject(overrideValue)
-			? mergeProjectConfigObjects(result[key], overrideValue)
-			: overrideValue;
-	}
-	return result;
-}
-
-function isPlainObject(value: unknown): value is Record<string, unknown> {
-	return Boolean(value) && typeof value === "object" && !Array.isArray(value);
-}
-
-async function expandIncludePath(configRoot: string, includePath: string): Promise<string[]> {
-	const resolvedIncludePath = resolveConfigPath(configRoot, includePath);
-	if (!hasGlobSegment(includePath)) return [resolvedIncludePath];
-	return expandGlobSegments(isAbsolute(includePath) ? sep : configRoot, splitPathSegments(includePath));
-}
-
-async function expandGlobSegments(root: string, segments: readonly string[]): Promise<string[]> {
-	if (segments.length === 0) return [root];
-	const [segment, ...remainingSegments] = segments;
-	if (segment === "*") {
-		const entries = await readdir(root, { withFileTypes: true });
-		const expanded = await Promise.all(entries
-			.filter((entry) => entry.isDirectory())
-			.sort((left, right) => left.name.localeCompare(right.name))
-			.map((entry) => expandGlobSegments(join(root, entry.name), remainingSegments)));
-		return expanded.flat();
-	}
-	return expandGlobSegments(join(root, segment), remainingSegments);
-}
-
-function resolveConfigPath(configRoot: string, path: string): string {
-	if (path.length === 0) throw new Error("Norn path must not be empty");
-	return isAbsolute(path) ? path : resolve(configRoot, path);
-}
-
-function hasGlobSegment(path: string): boolean {
-	return splitPathSegments(path).includes("*");
-}
-
-function splitPathSegments(path: string): string[] {
-	return path.split(/[\\/]+/).filter((segment) => segment.length > 0 && segment !== ".");
-}

package/assets/packages/cli/src/resources.ts

@@ -1,69 +0,0 @@
-import type { NornResourceDefinition, NornResources } from "@vimhead.dev/norn";
-import { writeJsonAtomically } from "@vimhead.dev/norn-core/atomic-files";
-import { isNodeError } from "@vimhead.dev/norn-core/errors";
-import { createRunFileCoordinator, type NornFileCoordinator } from "@vimhead.dev/norn/files";
-import { jsonValueSchema } from "@vimhead.dev/norn/schema";
-import { mkdir, readFile } from "node:fs/promises";
-import { join, resolve } from "node:path";
-import { isDeepStrictEqual } from "node:util";
-import { Type, type StaticDecode } from "typebox";
-import { Value } from "typebox/value";
-
-const definitionSchema = Type.Object({ name: Type.String(), kind: Type.String({ minLength: 1 }), configuration: jsonValueSchema }, { additionalProperties: false });
-const recordSchema = Type.Object({ ...definitionSchema.properties, isInitialized: Type.Boolean() }, { additionalProperties: false });
-
-export class NornRunResources implements NornResources {
-	readonly files: NornFileCoordinator;
-	private readonly entries = new Map<string, { readonly definition: StaticDecode<typeof definitionSchema>; readonly value: Promise<unknown> }>();
-
-	private constructor(private readonly runRoot: string) {
-		this.files = createRunFileCoordinator(runRoot);
-	}
-
-	static async initialize(runRoot: string): Promise<NornRunResources> {
-		const resources = new NornRunResources(resolve(runRoot));
-		await mkdir(join(resources.runRoot, "current", "resources"), { recursive: true });
-		return resources;
-	}
-
-	async ensure<T>(definition: NornResourceDefinition<T>): Promise<T> {
-		if (!/^[a-zA-Z0-9][a-zA-Z0-9_-]*$/.test(definition.name)) throw new Error(`Invalid resource name: ${definition.name}`);
-		const identity = structuredClone(Value.Parse(definitionSchema, { name: definition.name, kind: definition.kind, configuration: definition.configuration }));
-		const existing = this.entries.get(definition.name);
-		if (existing) {
-			if (!isDeepStrictEqual(existing.definition, identity)) throw new Error(`Incompatible resource definition: ${definition.name}`);
-			return existing.value as Promise<T>;
-		}
-		const value = this.initializeResource(definition, identity);
-		const entry = { definition: identity, value };
-		this.entries.set(definition.name, entry);
-		try {
-			return await value;
-		} catch (error) {
-			if (this.entries.get(definition.name) === entry) this.entries.delete(definition.name);
-			throw error;
-		}
-	}
-
-	private async initializeResource<T>(definition: NornResourceDefinition<T>, identity: StaticDecode<typeof definitionSchema>): Promise<T> {
-		const directory = join(this.runRoot, "current", "resources", definition.name);
-		await mkdir(directory, { recursive: true });
-		return this.files.withExclusiveLock(join(directory, "definition.json"), async (path) => {
-			let stored: StaticDecode<typeof recordSchema> | undefined;
-			try {
-				stored = Value.Parse(recordSchema, JSON.parse(await readFile(path, "utf8")));
-			} catch (error) {
-				if (!isNodeError(error) || error.code !== "ENOENT") throw error;
-			}
-			if (stored) {
-				const { isInitialized: _isInitialized, ...storedIdentity } = stored;
-				if (!isDeepStrictEqual(storedIdentity, identity)) throw new Error(`Incompatible resource definition: ${definition.name}`);
-			} else {
-				await writeJsonAtomically(path, { ...identity, isInitialized: false });
-			}
-			const value = await definition.initialize({ directory, files: this.files, mode: stored?.isInitialized ? "open" : "create" });
-			if (!stored?.isInitialized) await writeJsonAtomically(path, { ...identity, isInitialized: true });
-			return value;
-		});
-	}
-}

package/assets/packages/sdk/src/agent-resource-adapter.ts

@@ -1,11 +0,0 @@
-import type { ToolDefinition } from "@earendil-works/pi-coding-agent";
-
-export type NornAgentResourceBinding = {
-	readonly tools: readonly ToolDefinition[];
-	dispose(): Promise<void>;
-};
-
-export type NornAgentResourceAdapter = {
-	readonly name: string;
-	bind(context: { readonly runId: string; readonly label: string }): Promise<NornAgentResourceBinding>;
-};

package/assets/packages/sdk/src/resources.ts

@@ -1,20 +0,0 @@
-import type { NornFileCoordinator } from "./files.ts";
-import type { NornJsonValue } from "./schema.ts";
-
-export type NornResourceContext = {
-	readonly mode: "create" | "open";
-	readonly directory: string;
-	readonly files: NornFileCoordinator;
-};
-
-export type NornResourceDefinition<T> = {
-	readonly name: string;
-	readonly kind: string;
-	readonly configuration: NornJsonValue;
-	initialize(context: NornResourceContext): Promise<T>;
-};
-
-export type NornResources = {
-	readonly files: NornFileCoordinator;
-	ensure<T>(definition: NornResourceDefinition<T>): Promise<T>;
-};

package/assets/packages/sdk/src/state-adapter.ts

@@ -1,75 +0,0 @@
-import { defineTool } from "@earendil-works/pi-coding-agent";
-import { createHash } from "node:crypto";
-import { Type } from "typebox";
-import type { NornAgentResourceAdapter } from "./agent-resource-adapter.ts";
-import type { NornWorkflowState, NornWorkflowStateDefinition } from "./api.ts";
-import { inspectSchema } from "./schema.ts";
-
-export type NornStateFieldAccess = {
-	readonly field: NornWorkflowStateDefinition;
-	readonly access: "read" | "write" | "read-write";
-};
-
-const pageParameters = {
-	offset: Type.Integer({ minimum: 0, description: "Zero-based UTF-16 offset into the serialized JSON. Start at 0." }),
-	limit: Type.Integer({ minimum: 1, maximum: 10000 }),
-};
-
-export function StateAdapter(input: { readonly state: NornWorkflowState; readonly fields: readonly NornStateFieldAccess[] }): NornAgentResourceAdapter {
-	const fields = new Map(input.fields.map((grant) => [grant.field.id, grant]));
-	if (fields.size !== input.fields.length || fields.size === 0) throw new Error("State attachment requires unique, explicitly selected fields");
-	const selectField = (key: string, access: "read" | "write") => {
-		const grant = fields.get(key);
-		if (!grant || (grant.access !== access && grant.access !== "read-write")) throw new Error(`State ${access} is not attached: ${key}`);
-		return grant.field;
-	};
-	return {
-		name: "norn.state",
-		async bind() {
-			return {
-				tools: [
-					defineTool({
-						name: "norn_state_list",
-						label: "Attached workflow state",
-						description: "List only attached workflow-state field IDs, permissions and value schemas. JSON is paginated; use nextOffset until null.",
-						parameters: Type.Object(pageParameters),
-						async execute(_id, params) {
-							return serializePage({ value: [...fields.values()].map(({ field, access }) => ({ id: field.id, access, schema: inspectSchema(field.schema) })), ...params });
-						},
-					}),
-					defineTool({
-						name: "norn_state_get",
-						label: "Read workflow state",
-						description: "Read a selected workflow-state field. Unset fields return isSet:false. JSON is paginated; concurrent writes can change later pages, so compare revision before combining pages.",
-						parameters: Type.Object({ key: Type.String(), ...pageParameters }),
-						async execute(_id, params) {
-							const value = await input.state.getOptional(selectField(params.key, "read"));
-							return serializePage({ value: value === undefined ? { isSet: false } : { isSet: true, value }, ...params });
-						},
-					}),
-					defineTool({
-						name: "norn_state_set",
-						label: "Write workflow state",
-						description: "Set an explicitly writable workflow-state field. Validate the value against its schema from norn_state_list. A get followed by set is not a transaction.",
-						parameters: Type.Object({ key: Type.String(), value: Type.Unknown() }),
-						async execute(_id, params, signal) {
-							signal?.throwIfAborted();
-							const field = selectField(params.key, "write");
-							await input.state.set(field, params.value);
-							return { content: [{ type: "text", text: "Workflow state saved." }], details: {} };
-						},
-					}),
-				],
-				async dispose() {},
-			};
-		},
-	};
-}
-
-function serializePage(input: { readonly value: unknown; readonly offset: number; readonly limit: number }) {
-	const serialized = JSON.stringify(input.value);
-	if (!Number.isInteger(input.offset) || input.offset < 0 || !Number.isInteger(input.limit) || input.limit < 1 || input.limit > 10000) throw new Error("Invalid state output page");
-	const end = Math.min(serialized.length, input.offset + input.limit);
-	const details = { text: serialized.slice(input.offset, end), nextOffset: end < serialized.length ? end : null, revision: createHash("sha256").update(serialized).digest("hex") };
-	return { content: [{ type: "text" as const, text: JSON.stringify(details) }], details };
-}

package/dist/internal/artifacts.d.ts

@@ -1,10 +0,0 @@
-import type { NornFileCoordinator } from "@vimhead.dev/norn/files";
-import type { NornArtifactRef } from "@vimhead.dev/norn";
-export declare class NornArtifacts {
-    private readonly artifactsRoot;
-    private readonly files;
-    constructor(artifactsRoot: string, files: NornFileCoordinator);
-    write(path: string, content: string): Promise<NornArtifactRef>;
-    read(ref: NornArtifactRef): Promise<string>;
-    private resolveArtifactPath;
-}

package/dist/internal/artifacts.js

@@ -1,29 +0,0 @@
-// src/internal/artifacts.ts
-import { isAbsolute, relative, resolve, sep } from "node:path";
-var NornArtifacts = class {
-  constructor(artifactsRoot, files) {
-    this.artifactsRoot = artifactsRoot;
-    this.files = files;
-  }
-  artifactsRoot;
-  files;
-  async write(path, content) {
-    await this.files.writeText(this.resolveArtifactPath(path), content);
-    return { path };
-  }
-  async read(ref) {
-    return this.files.readText(this.resolveArtifactPath(ref.path));
-  }
-  resolveArtifactPath(path) {
-    if (isAbsolute(path)) throw new Error(`Artifact path must be relative: ${path}`);
-    const resolvedPath = resolve(this.artifactsRoot, path);
-    const relativePath = relative(this.artifactsRoot, resolvedPath);
-    if (relativePath === "" || relativePath === ".." || relativePath.startsWith(`..${sep}`) || isAbsolute(relativePath)) {
-      throw new Error(`Artifact path escapes artifacts directory: ${path}`);
-    }
-    return resolvedPath;
-  }
-};
-export {
-  NornArtifacts
-};

package/dist/internal/resource-bindings.d.ts

@@ -1,13 +0,0 @@
-import type { ToolDefinition } from "@earendil-works/pi-coding-agent";
-import type { NornAgentResourceAdapter } from "@vimhead.dev/norn";
-export declare class NornSessionResourceBindings {
-    readonly tools: ToolDefinition[];
-    private readonly bindings;
-    bind(input: {
-        readonly adapters: readonly NornAgentResourceAdapter[];
-        readonly runId: string;
-        readonly label: string;
-        readonly reservedTools: readonly string[];
-    }): Promise<void>;
-    dispose(): Promise<void>;
-}

package/dist/internal/resource-bindings.js

@@ -1,34 +0,0 @@
-// src/internal/resource-bindings.ts
-var NornSessionResourceBindings = class {
-  tools = [];
-  bindings = [];
-  async bind(input) {
-    const adapterNames = /* @__PURE__ */ new Set();
-    const tools = new Set(input.reservedTools);
-    for (const adapter of input.adapters) {
-      if (adapterNames.has(adapter.name)) throw new Error(`Duplicate resource adapter: ${adapter.name}`);
-      adapterNames.add(adapter.name);
-      const binding = await adapter.bind({ runId: input.runId, label: input.label });
-      this.bindings.push(binding);
-      for (const tool of binding.tools) {
-        if (tools.has(tool.name)) throw new Error(`Resource tool name collision: ${tool.name}`);
-        tools.add(tool.name);
-        this.tools.push(tool);
-      }
-    }
-  }
-  async dispose() {
-    const errors = [];
-    for (const binding of this.bindings.splice(0).reverse()) {
-      try {
-        await binding.dispose();
-      } catch (error) {
-        errors.push(error);
-      }
-    }
-    if (errors.length) throw new AggregateError(errors, "Resource binding cleanup failed");
-  }
-};
-export {
-  NornSessionResourceBindings
-};

package/dist/internal/run-resources.d.ts

@@ -1,6 +0,0 @@
-import { NornRunResources } from "../resources.ts";
-import { NornJsonWorkflowState } from "./state-store.ts";
-export declare function initializeRunResources(runRoot: string): Promise<{
-    readonly resources: NornRunResources;
-    readonly state: NornJsonWorkflowState;
-}>;