@tailor-platform/erp-kit 0.6.0 → 0.7.0

package/dist/cli.mjs

@@ -5,7 +5,7 @@ import { z } from "zod";
 import chalk from "chalk";
 import fs, { existsSync, globSync, readFileSync, readdirSync } from "node:fs";
 import path, { basename, dirname, join, relative, resolve } from "node:path";
-import { execFile, execSync } from "node:child_process";
+import { execFile, execFileSync, execSync } from "node:child_process";
 import fg from "fast-glob";
 import { fromMarkdown } from "mdast-util-from-markdown";
 import { toString } from "mdast-util-to-string";
@@ -488,8 +488,8 @@ function moduleCategories(root) {
 function appComposeCategories(root) {
 	return [{
 		name: "resolver",
-		sourcePattern: `${root}/*/backend/src/resolvers/*.ts`,
-		docPattern: `${root}/*/${APP_PATHS.docs.resolver}/*.md`,
+		sourcePattern: `${root}/backend/src/resolvers/*.ts`,
+		docPattern: `${root}/${APP_PATHS.docs.resolver}/*.md`,
 		exclusions: [/\.test\.ts$/, /^index\.ts$/]
 	}];
 }
@@ -535,22 +535,22 @@ function buildCheckTargets(config) {
 	if (config.appRoot) {
 		const a = config.appRoot;
 		targets.push({
-			glob: `${a}/[a-zA-Z]*/README.md`,
+			glob: `${a}/README.md`,
 			schemaKey: "app"
 		}, {
-			glob: `${a}/[a-zA-Z]*/${APP_PATHS.docs.actors}/*.md`,
+			glob: `${a}/${APP_PATHS.docs.actors}/*.md`,
 			schemaKey: "actors"
 		}, {
-			glob: `${a}/[a-zA-Z]*/${APP_PATHS.docs.businessFlow}/*/README.md`,
+			glob: `${a}/${APP_PATHS.docs.businessFlow}/*/README.md`,
 			schemaKey: "business-flow"
 		}, {
-			glob: `${a}/[a-zA-Z]*/${APP_PATHS.docs.businessFlow}/*/${APP_PATHS.docs.story}/*.md`,
+			glob: `${a}/${APP_PATHS.docs.businessFlow}/*/${APP_PATHS.docs.story}/*.md`,
 			schemaKey: "story"
 		}, {
-			glob: `${a}/[a-zA-Z]*/${APP_PATHS.docs.screen}/*.md`,
+			glob: `${a}/${APP_PATHS.docs.screen}/*.md`,
 			schemaKey: "screen"
 		}, {
-			glob: `${a}/[a-zA-Z]*/${APP_PATHS.docs.resolver}/*.md`,
+			glob: `${a}/${APP_PATHS.docs.resolver}/*.md`,
 			schemaKey: "resolver"
 		});
 	}
@@ -630,6 +630,12 @@ async function runInitAppWithReadme(name, dir, cwd) {
 function success() {
 	return { exitCode: 0 };
 }
+function failure(message, exitCode = 1) {
+	return {
+		exitCode,
+		message
+	};
+}
 function silentFailure(exitCode = 1) {
 	return {
 		exitCode,
@@ -766,7 +772,16 @@ async function runModuleTestCaseSyncCheck(root, cwd) {
 			const testFileName = `${toCamelCase(docBasename)}.test.ts`;
 			const testPath = path.join(modulePath, category.testDir, testFileName);
 			const testFullPath = path.join(cwd, testPath);
-			if (!fs.existsSync(testFullPath)) continue;
+			if (!fs.existsSync(testFullPath)) {
+				errors.push({
+					type: "missing-test-file",
+					category: category.name,
+					docPath,
+					sourcePath: testPath,
+					expectedBasename: testFileName
+				});
+				continue;
+			}
 			const itDescriptions = parseItDescriptionsFromTest(fs.readFileSync(testFullPath, "utf-8"));
 			const docSet = new Set(docTestCases);
 			const testSet = new Set(itDescriptions);
@@ -805,7 +820,16 @@ async function runAppTestCaseSyncCheck(appRoot, cwd) {
 		const testPath = resolveStoryTestPath(docPath, config.testDir);
 		if (!testPath) continue;
 		const testFullPath = path.join(cwd, testPath);
-		if (!fs.existsSync(testFullPath)) continue;
+		if (!fs.existsSync(testFullPath)) {
+			errors.push({
+				type: "missing-test-file",
+				category: config.name,
+				docPath,
+				sourcePath: testPath,
+				expectedBasename: path.basename(testPath)
+			});
+			continue;
+		}
 		const itDescriptions = parseItDescriptionsFromTest(fs.readFileSync(testFullPath, "utf-8"));
 		const docSet = new Set(docTestCases);
 		const testSet = new Set(itDescriptions);
@@ -867,6 +891,9 @@ function formatSyncCheckReport(result) {
 				} else if (error.type === "extra-test-case") {
 					lines.push(`  ${chalk.red(error.sourcePath)}`);
 					lines.push(`    ${chalk.yellow("Extra test case:")} "${error.expectedBasename}" is in test but not in doc`);
+				} else if (error.type === "missing-test-file") {
+					lines.push(`  ${chalk.red(error.docPath)}`);
+					lines.push(`    ${chalk.yellow("Missing test file:")} ${error.expectedBasename}`);
 				}
 				lines.push("");
 			}
@@ -1130,18 +1157,6 @@ export default createResolver({
     })
     .description("${toPascal(name)} response"),
 });
-`;
-	} },
-	resolverTest: { render: (name) => {
-		return `import { describe, expect, it } from "vitest";
-
-describe("${name}", () => {
-  it("should be implemented", async () => {
-    const resolver = await import("./${name}");
-    expect(resolver.default).toBeDefined();
-    expect(resolver.default.name).toBe("${name}");
-  });
-});
 `;
 	} },
 	storyTest: { render: (name, testCases) => {
@@ -1161,32 +1176,6 @@ function renderStub(type, name, testCases) {
 	return templates[type].render(name);
 }
 //#endregion
-//#region src/generator/generate-stubs.ts
-function generateCommandStub(doc) {
-	return renderStub("command", doc.commandName);
-}
-function generateTestStub(doc) {
-	return renderStub("commandTest", doc.commandName);
-}
-function generateQueryStub(doc) {
-	return renderStub("query", doc.commandName);
-}
-function generateQueryTestStub(doc) {
-	return renderStub("queryTest", doc.commandName);
-}
-function generateDbStub(modelName) {
-	return renderStub("db", modelName);
-}
-function generateResolverStub(resolverName) {
-	return renderStub("resolver", resolverName);
-}
-function generateResolverTestStub(resolverName) {
-	return renderStub("resolverTest", resolverName);
-}
-function generateStoryTestStub(name, testCases) {
-	return renderStub("storyTest", name, testCases);
-}
-//#endregion
 //#region src/generator/scaffold.ts
 function copyTemplateDir(srcDir, destDir, replacements, placeholderFiles) {
 	for (const entry of fs.readdirSync(srcDir, { withFileTypes: true })) {
@@ -1291,12 +1280,12 @@ function runGenerateCode(modulePath, moduleName) {
 		console.log(`  wrote ${path.relative(modulePath, shellFile)}`);
 		generated++;
 		if (!fs.existsSync(implFile)) {
-			fs.writeFileSync(implFile, generateCommandStub(doc));
+			fs.writeFileSync(implFile, renderStub("command", doc.commandName));
 			console.log(`  scaffolded ${path.relative(modulePath, implFile)}`);
 		}
 		const testFile = path.join(commandDir, `${doc.commandName}.test.ts`);
 		if (!fs.existsSync(testFile)) {
-			fs.writeFileSync(testFile, generateTestStub(doc));
+			fs.writeFileSync(testFile, renderStub("commandTest", doc.commandName));
 			console.log(`  scaffolded ${path.relative(modulePath, testFile)}`);
 		}
 	}
@@ -1314,12 +1303,12 @@ function runGenerateCode(modulePath, moduleName) {
 				generated++;
 				const implFile = path.join(queryDir, `${doc.commandName}.ts`);
 				if (!fs.existsSync(implFile)) {
-					fs.writeFileSync(implFile, generateQueryStub(doc));
+					fs.writeFileSync(implFile, renderStub("query", doc.commandName));
 					console.log(`  scaffolded ${path.relative(modulePath, implFile)}`);
 				}
 				const testFile = path.join(queryDir, `${doc.commandName}.test.ts`);
 				if (!fs.existsSync(testFile)) {
-					fs.writeFileSync(testFile, generateQueryTestStub(doc));
+					fs.writeFileSync(testFile, renderStub("queryTest", doc.commandName));
 					console.log(`  scaffolded ${path.relative(modulePath, testFile)}`);
 				}
 			}
@@ -1336,7 +1325,7 @@ function runGenerateCode(modulePath, moduleName) {
 				const camelName = modelName.charAt(0).toLowerCase() + modelName.slice(1);
 				const dbFile = path.join(dbDir, `${camelName}.ts`);
 				if (!fs.existsSync(dbFile)) {
-					fs.writeFileSync(dbFile, generateDbStub(camelName));
+					fs.writeFileSync(dbFile, renderStub("db", camelName));
 					console.log(`  scaffolded ${path.relative(modulePath, dbFile)}`);
 				}
 			}
@@ -1416,7 +1405,7 @@ async function runGenerateDoc(type, name, modulePath, cwd) {
 }
 //#endregion
 //#region src/commands/module/generate.ts
-const cwd$3 = process.cwd();
+const cwd$4 = process.cwd();
 const pathArgs$2 = z.object({ path: arg(z.string(), {
 	alias: "p",
 	description: "Path to the module directory"
@@ -1440,7 +1429,7 @@ const generateCommand$1 = defineCommand({
 			}),
 			run: (args) => {
 				return executeCommand(async () => {
-					const exitCode = await runGenerateDoc(args.type, args.name, args.path, cwd$3);
+					const exitCode = await runGenerateDoc(args.type, args.name, args.path, cwd$4);
 					return exitCode === 0 ? success() : silentFailure(exitCode);
 				});
 			}
@@ -1451,7 +1440,7 @@ const generateCommand$1 = defineCommand({
 			args: pathArgs$2,
 			run: (args) => {
 				return executeCommand(() => {
-					const modulePath = path.resolve(cwd$3, args.path);
+					const modulePath = path.resolve(cwd$4, args.path);
 					const moduleName = path.basename(modulePath);
 					console.log(`Generating code for ${moduleName}...`);
 					const exitCode = runGenerateCode(modulePath, moduleName);
@@ -1463,7 +1452,7 @@ const generateCommand$1 = defineCommand({
 });
 //#endregion
 //#region src/commands/module/index.ts
-const cwd$2 = process.cwd();
+const cwd$3 = process.cwd();
 const pathArgs$1 = z.object({ path: arg(z.string(), {
 	alias: "p",
 	description: "Path to modules directory"
@@ -1474,7 +1463,7 @@ const checkCommand$1 = defineCommand({
 	args: pathArgs$1,
 	run: (args) => {
 		return executeCommand(async () => {
-			const exitCode = await runCheck({ modulesRoot: args.path }, cwd$2);
+			const exitCode = await runCheck({ modulesRoot: args.path }, cwd$3);
 			return exitCode === 0 ? success() : silentFailure(exitCode);
 		});
 	}
@@ -1485,7 +1474,7 @@ const syncCheckCommand$1 = defineCommand({
 	args: pathArgs$1,
 	run: (args) => {
 		return executeCommand(async () => {
-			const result = await runSyncCheck({ modulesRoot: args.path }, cwd$2);
+			const result = await runSyncCheck({ modulesRoot: args.path }, cwd$3);
 			console.log(formatSyncCheckReport(result));
 			return result.exitCode === 0 ? success() : silentFailure(result.exitCode);
 		});
@@ -1506,7 +1495,7 @@ const initCommand$2 = defineCommand({
 	}),
 	run: (args) => {
 		return executeCommand(async () => {
-			const exitCode = await runInitModuleWithReadme(args.name, args.dir, cwd$2);
+			const exitCode = await runInitModuleWithReadme(args.name, args.dir, cwd$3);
 			return exitCode === 0 ? success() : silentFailure(exitCode);
 		});
 	}
@@ -1622,15 +1611,10 @@ function generateResolverStubs(appPath, appName) {
 		const doc = parseResolverDoc(path.basename(file, ".md"), content);
 		const implFile = path.join(resolverDir, `${doc.resolverName}.ts`);
 		if (!fs.existsSync(implFile)) {
-			fs.writeFileSync(implFile, generateResolverStub(doc.resolverName));
+			fs.writeFileSync(implFile, renderStub("resolver", doc.resolverName));
 			console.log(`  scaffolded ${path.relative(appPath, implFile)}`);
 			generated++;
 		}
-		const testFile = path.join(resolverDir, `${doc.resolverName}.test.ts`);
-		if (!fs.existsSync(testFile)) {
-			fs.writeFileSync(testFile, generateResolverTestStub(doc.resolverName));
-			console.log(`  scaffolded ${path.relative(appPath, testFile)}`);
-		}
 	}
 	if (generated > 0) console.log(`Scaffolded ${generated} resolver(s) for ${appName}`);
 }
@@ -1647,7 +1631,7 @@ function generateStoryTestStubs(appPath, appName) {
 		const testFile = path.join(testDir, `${storyName}.test.ts`);
 		if (fs.existsSync(testFile)) continue;
 		fs.mkdirSync(testDir, { recursive: true });
-		fs.writeFileSync(testFile, generateStoryTestStub(storyName, testCases));
+		fs.writeFileSync(testFile, renderStub("storyTest", storyName, testCases));
 		console.log(`  scaffolded ${path.relative(appPath, testFile)}`);
 		generated++;
 	}
@@ -2038,6 +2022,359 @@ function runGenerateSeed(appPath) {
 	console.log(`Generated ${written} file(s), skipped ${skipped} existing`);
 	return 0;
 }
+z.enum([
+	"step.start",
+	"step.complete",
+	"decision",
+	"agent.dispatch",
+	"agent.result",
+	"artifact.create",
+	"validation",
+	"error",
+	"note"
+]);
+const StepStatus = z.enum([
+	"pass",
+	"fail",
+	"blocked"
+]);
+const ArtifactType = z.enum([
+	"doc",
+	"code",
+	"config",
+	"report",
+	"seed",
+	"asset"
+]);
+const ArtifactOperation = z.enum([
+	"create",
+	"update",
+	"delete"
+]);
+const ConversationMessage = z.object({
+	role: z.enum(["user", "agent"]),
+	message: z.string()
+});
+const GitContext = z.object({
+	branch: z.string(),
+	commit: z.string()
+});
+const StepStartData = z.object({
+	skill: z.string(),
+	context: z.record(z.string(), z.unknown())
+});
+const StepCompleteData = z.object({
+	status: StepStatus,
+	summary: z.string(),
+	artifacts: z.array(z.string())
+});
+const DecisionData = z.object({
+	question: z.string(),
+	choice: z.string(),
+	alternatives: z.array(z.string()),
+	rationale: z.string()
+});
+const AgentDispatchData = z.object({
+	agentName: z.string(),
+	task: z.string(),
+	inputs: z.record(z.string(), z.unknown())
+});
+const AgentResultData = z.object({
+	agentName: z.string(),
+	status: z.enum(["pass", "fail"]),
+	outputs: z.record(z.string(), z.unknown()),
+	duration_ms: z.number()
+});
+const ArtifactCreateData = z.object({
+	path: z.string(),
+	type: ArtifactType,
+	operation: ArtifactOperation
+});
+const ValidationData = z.object({
+	command: z.string(),
+	status: z.enum(["pass", "fail"]),
+	issues: z.array(z.string())
+});
+const ErrorData = z.object({
+	message: z.string(),
+	recoverable: z.boolean()
+});
+const NoteData = z.object({
+	message: z.string(),
+	tags: z.array(z.string())
+});
+const convField = () => z.array(ConversationMessage).default([]);
+const StepStartEntry = z.object({
+	v: z.literal(1),
+	timestamp: z.string().datetime(),
+	sessionId: z.string(),
+	prompt: z.string(),
+	git: GitContext,
+	conversation: convField(),
+	event: z.literal("step.start"),
+	data: StepStartData
+});
+const StepCompleteEntry = z.object({
+	v: z.literal(1),
+	timestamp: z.string().datetime(),
+	sessionId: z.string(),
+	prompt: z.string(),
+	git: GitContext,
+	conversation: convField(),
+	event: z.literal("step.complete"),
+	data: StepCompleteData
+});
+const DecisionEntry = z.object({
+	v: z.literal(1),
+	timestamp: z.string().datetime(),
+	sessionId: z.string(),
+	prompt: z.string(),
+	git: GitContext,
+	conversation: convField(),
+	event: z.literal("decision"),
+	data: DecisionData
+});
+const AgentDispatchEntry = z.object({
+	v: z.literal(1),
+	timestamp: z.string().datetime(),
+	sessionId: z.string(),
+	prompt: z.string(),
+	git: GitContext,
+	conversation: convField(),
+	event: z.literal("agent.dispatch"),
+	data: AgentDispatchData
+});
+const AgentResultEntry = z.object({
+	v: z.literal(1),
+	timestamp: z.string().datetime(),
+	sessionId: z.string(),
+	prompt: z.string(),
+	git: GitContext,
+	conversation: convField(),
+	event: z.literal("agent.result"),
+	data: AgentResultData
+});
+const ArtifactCreateEntry = z.object({
+	v: z.literal(1),
+	timestamp: z.string().datetime(),
+	sessionId: z.string(),
+	prompt: z.string(),
+	git: GitContext,
+	conversation: convField(),
+	event: z.literal("artifact.create"),
+	data: ArtifactCreateData
+});
+const ValidationEntry = z.object({
+	v: z.literal(1),
+	timestamp: z.string().datetime(),
+	sessionId: z.string(),
+	prompt: z.string(),
+	git: GitContext,
+	conversation: convField(),
+	event: z.literal("validation"),
+	data: ValidationData
+});
+const ErrorEntry = z.object({
+	v: z.literal(1),
+	timestamp: z.string().datetime(),
+	sessionId: z.string(),
+	prompt: z.string(),
+	git: GitContext,
+	conversation: convField(),
+	event: z.literal("error"),
+	data: ErrorData
+});
+const NoteEntry = z.object({
+	v: z.literal(1),
+	timestamp: z.string().datetime(),
+	sessionId: z.string(),
+	prompt: z.string(),
+	git: GitContext,
+	conversation: convField(),
+	event: z.literal("note"),
+	data: NoteData
+});
+const ProgressEntry = z.union([
+	StepStartEntry,
+	StepCompleteEntry,
+	DecisionEntry,
+	AgentDispatchEntry,
+	AgentResultEntry,
+	ArtifactCreateEntry,
+	ValidationEntry,
+	ErrorEntry,
+	NoteEntry
+]);
+const StepStartInput = z.object({
+	v: z.literal(1),
+	sessionId: z.string(),
+	prompt: z.string(),
+	conversation: convField(),
+	event: z.literal("step.start"),
+	data: StepStartData
+});
+const StepCompleteInput = z.object({
+	v: z.literal(1),
+	sessionId: z.string(),
+	prompt: z.string(),
+	conversation: convField(),
+	event: z.literal("step.complete"),
+	data: StepCompleteData
+});
+const DecisionInput = z.object({
+	v: z.literal(1),
+	sessionId: z.string(),
+	prompt: z.string(),
+	conversation: convField(),
+	event: z.literal("decision"),
+	data: DecisionData
+});
+const AgentDispatchInput = z.object({
+	v: z.literal(1),
+	sessionId: z.string(),
+	prompt: z.string(),
+	conversation: convField(),
+	event: z.literal("agent.dispatch"),
+	data: AgentDispatchData
+});
+const AgentResultInput = z.object({
+	v: z.literal(1),
+	sessionId: z.string(),
+	prompt: z.string(),
+	conversation: convField(),
+	event: z.literal("agent.result"),
+	data: AgentResultData
+});
+const ArtifactCreateInput = z.object({
+	v: z.literal(1),
+	sessionId: z.string(),
+	prompt: z.string(),
+	conversation: convField(),
+	event: z.literal("artifact.create"),
+	data: ArtifactCreateData
+});
+const ValidationInput = z.object({
+	v: z.literal(1),
+	sessionId: z.string(),
+	prompt: z.string(),
+	conversation: convField(),
+	event: z.literal("validation"),
+	data: ValidationData
+});
+const ErrorInput = z.object({
+	v: z.literal(1),
+	sessionId: z.string(),
+	prompt: z.string(),
+	conversation: convField(),
+	event: z.literal("error"),
+	data: ErrorData
+});
+const NoteInput = z.object({
+	v: z.literal(1),
+	sessionId: z.string(),
+	prompt: z.string(),
+	conversation: convField(),
+	event: z.literal("note"),
+	data: NoteData
+});
+const ProgressInput = z.union([
+	StepStartInput,
+	StepCompleteInput,
+	DecisionInput,
+	AgentDispatchInput,
+	AgentResultInput,
+	ArtifactCreateInput,
+	ValidationInput,
+	ErrorInput,
+	NoteInput
+]);
+//#endregion
+//#region src/commands/app/progress/git-context.ts
+function getGitContext(cwd) {
+	return {
+		branch: execFileSync("git", [
+			"rev-parse",
+			"--abbrev-ref",
+			"HEAD"
+		], {
+			cwd,
+			encoding: "utf-8"
+		}).trim(),
+		commit: execFileSync("git", [
+			"rev-parse",
+			"--short",
+			"HEAD"
+		], {
+			cwd,
+			encoding: "utf-8"
+		}).trim()
+	};
+}
+//#endregion
+//#region src/commands/app/progress/log.ts
+function runProgressLog(jsonInput, dryRun, cwd) {
+	let parsed;
+	try {
+		parsed = JSON.parse(jsonInput);
+	} catch {
+		return failure("Invalid JSON input");
+	}
+	const inputResult = ProgressInput.safeParse(parsed);
+	if (!inputResult.success) return failure(`Invalid progress input: ${inputResult.error.issues.map((i) => `${i.path.join(".")}: ${i.message}`).join(", ")}`);
+	const enriched = {
+		...inputResult.data,
+		timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+		git: getGitContext(cwd)
+	};
+	const entryResult = ProgressEntry.safeParse(enriched);
+	if (!entryResult.success) return failure(`Invalid progress entry after enrichment: ${entryResult.error.issues.map((i) => `${i.path.join(".")}: ${i.message}`).join(", ")}`);
+	const line = JSON.stringify(entryResult.data);
+	console.log(line);
+	if (dryRun) return success();
+	const erpKitDir = path.join(cwd, ".erp-kit");
+	fs.mkdirSync(erpKitDir, { recursive: true });
+	fs.appendFileSync(path.join(erpKitDir, "progress.jsonl"), line + "\n", "utf-8");
+	return success();
+}
+//#endregion
+//#region src/commands/app/progress/schema-cmd.ts
+function runProgressSchema() {
+	const jsonSchema = z.toJSONSchema(ProgressInput);
+	console.log(JSON.stringify(jsonSchema, null, 2));
+	return success();
+}
+//#endregion
+//#region src/commands/app/progress/index.ts
+const cwd$2 = process.cwd();
+const progressCommand = defineCommand({
+	name: "progress",
+	description: "Audit log for app skill sessions",
+	subCommands: {
+		log: defineCommand({
+			name: "log",
+			description: "Append a validated entry to the progress log",
+			args: z.object({
+				json: arg(z.string(), { description: "JSON payload (ProgressInput schema)" }),
+				"dry-run": arg(z.boolean().default(false), { description: "Validate without writing" })
+			}),
+			run: (args) => {
+				return executeCommand(() => {
+					return runProgressLog(args.json, args["dry-run"], cwd$2);
+				});
+			}
+		}),
+		schema: defineCommand({
+			name: "schema",
+			description: "Output JSON Schema for progress log input",
+			args: z.object({}),
+			run: () => {
+				return executeCommand(() => {
+					return runProgressSchema();
+				});
+			}
+		})
+	}
+});
 //#endregion
 //#region src/commands/app/index.ts
 const cwd$1 = process.cwd();
@@ -2143,7 +2480,8 @@ const appCommand = defineCommand({
 		check: checkCommand,
 		"sync-check": syncCheckCommand,
 		init: initCommand$1,
-		generate: generateCommand
+		generate: generateCommand,
+		progress: progressCommand
 	}
 });
 //#endregion

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tailor-platform/erp-kit",
-  "version": "0.6.0",
+  "version": "0.7.0",
   "description": "Opinionated ERP toolkit for building business applications on Tailor Platform",
   "license": "MIT",
   "bin": {