@majeanson/lac 3.0.0 → 3.0.2

package/dist/mcp.mjs

@@ -1,10 +1,12 @@
 import fs from "node:fs";
 import path from "node:path";
-import process from "node:process";
+import process$1 from "node:process";
 import { Server } from "@modelcontextprotocol/sdk/server/index.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { CallToolRequestSchema, ListToolsRequestSchema } from "@modelcontextprotocol/sdk/types.js";
-import { fillFeature, genFromFeature } from "@life-as-code/lac-claude";
+import readline from "node:readline";
+import Anthropic from "@anthropic-ai/sdk";
+import { execSync } from "node:child_process";
 
 //#region ../../node_modules/.bun/zod@4.3.6/node_modules/zod/v4/core/core.js
 /** A special constant with type `never` */
@@ -2606,7 +2608,7 @@ function initializeContext(params) {
 		external: params?.external ?? void 0
 	};
 }
-function process$1(schema, ctx, _params = {
+function process$2(schema, ctx, _params = {
 	path: [],
 	schemaPath: []
 }) {
@@ -2643,7 +2645,7 @@ function process$1(schema, ctx, _params = {
 		const parent = schema._zod.parent;
 		if (parent) {
 			if (!result.ref) result.ref = parent;
-			process$1(parent, ctx, params);
+			process$2(parent, ctx, params);
 			ctx.seen.get(parent).isParent = true;
 		}
 	}
@@ -2855,7 +2857,7 @@ const createToJSONSchemaMethod = (schema, processors = {}) => (params) => {
 		...params,
 		processors
 	});
-	process$1(schema, ctx);
+	process$2(schema, ctx);
 	extractDefs(ctx, schema);
 	return finalize(ctx, schema);
 };
@@ -2867,7 +2869,7 @@ const createStandardJSONSchemaMethod = (schema, io, processors = {}) => (params)
 		io,
 		processors
 	});
-	process$1(schema, ctx);
+	process$2(schema, ctx);
 	extractDefs(ctx, schema);
 	return finalize(ctx, schema);
 };
@@ -2951,7 +2953,7 @@ const arrayProcessor = (schema, ctx, _json, params) => {
 	if (typeof minimum === "number") json.minItems = minimum;
 	if (typeof maximum === "number") json.maxItems = maximum;
 	json.type = "array";
-	json.items = process$1(def.element, ctx, {
+	json.items = process$2(def.element, ctx, {
 		...params,
 		path: [...params.path, "items"]
 	});
@@ -2962,7 +2964,7 @@ const objectProcessor = (schema, ctx, _json, params) => {
 	json.type = "object";
 	json.properties = {};
 	const shape = def.shape;
-	for (const key in shape) json.properties[key] = process$1(shape[key], ctx, {
+	for (const key in shape) json.properties[key] = process$2(shape[key], ctx, {
 		...params,
 		path: [
 			...params.path,
@@ -2980,7 +2982,7 @@ const objectProcessor = (schema, ctx, _json, params) => {
 	if (def.catchall?._zod.def.type === "never") json.additionalProperties = false;
 	else if (!def.catchall) {
 		if (ctx.io === "output") json.additionalProperties = false;
-	} else if (def.catchall) json.additionalProperties = process$1(def.catchall, ctx, {
+	} else if (def.catchall) json.additionalProperties = process$2(def.catchall, ctx, {
 		...params,
 		path: [...params.path, "additionalProperties"]
 	});
@@ -2988,7 +2990,7 @@ const objectProcessor = (schema, ctx, _json, params) => {
 const unionProcessor = (schema, ctx, json, params) => {
 	const def = schema._zod.def;
 	const isExclusive = def.inclusive === false;
-	const options = def.options.map((x, i) => process$1(x, ctx, {
+	const options = def.options.map((x, i) => process$2(x, ctx, {
 		...params,
 		path: [
 			...params.path,
@@ -3001,7 +3003,7 @@ const unionProcessor = (schema, ctx, json, params) => {
 };
 const intersectionProcessor = (schema, ctx, json, params) => {
 	const def = schema._zod.def;
-	const a = process$1(def.left, ctx, {
+	const a = process$2(def.left, ctx, {
 		...params,
 		path: [
 			...params.path,
@@ -3009,7 +3011,7 @@ const intersectionProcessor = (schema, ctx, json, params) => {
 			0
 		]
 	});
-	const b = process$1(def.right, ctx, {
+	const b = process$2(def.right, ctx, {
 		...params,
 		path: [
 			...params.path,
@@ -3022,7 +3024,7 @@ const intersectionProcessor = (schema, ctx, json, params) => {
 };
 const nullableProcessor = (schema, ctx, json, params) => {
 	const def = schema._zod.def;
-	const inner = process$1(def.innerType, ctx, params);
+	const inner = process$2(def.innerType, ctx, params);
 	const seen = ctx.seen.get(schema);
 	if (ctx.target === "openapi-3.0") {
 		seen.ref = def.innerType;
@@ -3031,27 +3033,27 @@ const nullableProcessor = (schema, ctx, json, params) => {
 };
 const nonoptionalProcessor = (schema, ctx, _json, params) => {
 	const def = schema._zod.def;
-	process$1(def.innerType, ctx, params);
+	process$2(def.innerType, ctx, params);
 	const seen = ctx.seen.get(schema);
 	seen.ref = def.innerType;
 };
 const defaultProcessor = (schema, ctx, json, params) => {
 	const def = schema._zod.def;
-	process$1(def.innerType, ctx, params);
+	process$2(def.innerType, ctx, params);
 	const seen = ctx.seen.get(schema);
 	seen.ref = def.innerType;
 	json.default = JSON.parse(JSON.stringify(def.defaultValue));
 };
 const prefaultProcessor = (schema, ctx, json, params) => {
 	const def = schema._zod.def;
-	process$1(def.innerType, ctx, params);
+	process$2(def.innerType, ctx, params);
 	const seen = ctx.seen.get(schema);
 	seen.ref = def.innerType;
 	if (ctx.io === "input") json._prefault = JSON.parse(JSON.stringify(def.defaultValue));
 };
 const catchProcessor = (schema, ctx, json, params) => {
 	const def = schema._zod.def;
-	process$1(def.innerType, ctx, params);
+	process$2(def.innerType, ctx, params);
 	const seen = ctx.seen.get(schema);
 	seen.ref = def.innerType;
 	let catchValue;
@@ -3065,20 +3067,20 @@ const catchProcessor = (schema, ctx, json, params) => {
 const pipeProcessor = (schema, ctx, _json, params) => {
 	const def = schema._zod.def;
 	const innerType = ctx.io === "input" ? def.in._zod.def.type === "transform" ? def.out : def.in : def.out;
-	process$1(innerType, ctx, params);
+	process$2(innerType, ctx, params);
 	const seen = ctx.seen.get(schema);
 	seen.ref = innerType;
 };
 const readonlyProcessor = (schema, ctx, json, params) => {
 	const def = schema._zod.def;
-	process$1(def.innerType, ctx, params);
+	process$2(def.innerType, ctx, params);
 	const seen = ctx.seen.get(schema);
 	seen.ref = def.innerType;
 	json.readOnly = true;
 };
 const optionalProcessor = (schema, ctx, _json, params) => {
 	const def = schema._zod.def;
-	process$1(def.innerType, ctx, params);
+	process$2(def.innerType, ctx, params);
 	const seen = ctx.seen.get(schema);
 	seen.ref = def.innerType;
 };
@@ -3773,9 +3775,437 @@ function validateFeature(data) {
 	};
 }
 
+//#endregion
+//#region ../lac-claude/dist/index.mjs
+function createClient() {
+	let apiKey = process$1.env.ANTHROPIC_API_KEY;
+	if (!apiKey) {
+		const configPath = findLacConfig();
+		if (configPath) try {
+			apiKey = JSON.parse(fs.readFileSync(configPath, "utf-8"))?.ai?.apiKey;
+		} catch {}
+	}
+	if (!apiKey) throw new Error("ANTHROPIC_API_KEY not set.\nSet it via:\n  export ANTHROPIC_API_KEY=sk-ant-...\nOr add it to .lac/config.json:\n  { \"ai\": { \"apiKey\": \"sk-ant-...\" } }\nGet a key at https://console.anthropic.com/settings/keys");
+	return new Anthropic({ apiKey });
+}
+function findLacConfig() {
+	let current = process$1.cwd();
+	while (true) {
+		const candidate = path.join(current, ".lac", "config.json");
+		if (fs.existsSync(candidate)) return candidate;
+		const parent = path.dirname(current);
+		if (parent === current) return null;
+		current = parent;
+	}
+}
+async function generateText(client, systemPrompt, userMessage, model = "claude-sonnet-4-6") {
+	const content = (await client.messages.create({
+		model,
+		max_tokens: 4096,
+		system: systemPrompt,
+		messages: [{
+			role: "user",
+			content: userMessage
+		}]
+	})).content[0];
+	if (!content || content.type !== "text") throw new Error("Unexpected response type from Claude API");
+	return content.text;
+}
+const SOURCE_EXTENSIONS = new Set([
+	".ts",
+	".tsx",
+	".js",
+	".jsx",
+	".py",
+	".go",
+	".rs",
+	".java",
+	".cs",
+	".rb",
+	".php",
+	".vue",
+	".svelte",
+	".sql"
+]);
+const MAX_FILE_CHARS = 8e3;
+const MAX_TOTAL_CHARS = 32e4;
+function buildContext(featureDir, feature) {
+	return {
+		feature,
+		featurePath: path.join(featureDir, "feature.json"),
+		sourceFiles: gatherSourceFiles(featureDir),
+		gitLog: getGitLog(featureDir)
+	};
+}
+function gatherSourceFiles(dir) {
+	const files = [];
+	let totalChars = 0;
+	const priorityNames = [
+		"package.json",
+		"README.md",
+		"tsconfig.json",
+		".env.example"
+	];
+	for (const name of priorityNames) {
+		const p = path.join(dir, name);
+		if (fs.existsSync(p)) try {
+			const content = truncate(fs.readFileSync(p, "utf-8"), 4e3);
+			files.push({
+				relativePath: name,
+				content
+			});
+			totalChars += content.length;
+		} catch {}
+	}
+	const allSource = walkDir(dir).filter((f) => SOURCE_EXTENSIONS.has(path.extname(f)) && !f.includes("node_modules") && !f.includes(".turbo") && !f.includes("dist/"));
+	allSource.sort((a, b) => {
+		const aTest = /\.(test|spec)\.(ts|tsx|js|jsx)$/.test(a);
+		return aTest === /\.(test|spec)\.(ts|tsx|js|jsx)$/.test(b) ? 0 : aTest ? 1 : -1;
+	});
+	for (const filePath of allSource) {
+		if (totalChars >= MAX_TOTAL_CHARS) break;
+		if (priorityNames.includes(path.basename(filePath))) continue;
+		try {
+			const content = truncate(fs.readFileSync(filePath, "utf-8"), MAX_FILE_CHARS);
+			const relativePath = path.relative(dir, filePath);
+			files.push({
+				relativePath,
+				content
+			});
+			totalChars += content.length;
+		} catch {}
+	}
+	return files;
+}
+function walkDir(dir) {
+	const results = [];
+	try {
+		const entries = fs.readdirSync(dir, { withFileTypes: true });
+		for (const entry of entries) {
+			if (entry.name.startsWith(".") || entry.name === "node_modules" || entry.name === "dist") continue;
+			const full = path.join(dir, entry.name);
+			if (entry.isDirectory()) results.push(...walkDir(full));
+			else results.push(full);
+		}
+	} catch {}
+	return results;
+}
+function truncate(content, maxChars) {
+	if (content.length <= maxChars) return content;
+	return content.slice(0, maxChars) + "\n... [truncated]";
+}
+function getGitLog(dir) {
+	try {
+		return execSync("git log --oneline --follow -20 -- .", {
+			cwd: dir,
+			encoding: "utf-8",
+			stdio: [
+				"pipe",
+				"pipe",
+				"pipe"
+			]
+		}).trim();
+	} catch {
+		return "";
+	}
+}
+function contextToString(ctx) {
+	const parts = [];
+	parts.push("=== feature.json ===");
+	parts.push(JSON.stringify(ctx.feature, null, 2));
+	if (ctx.gitLog) {
+		parts.push("\n=== git log (last 20 commits) ===");
+		parts.push(ctx.gitLog);
+	}
+	for (const file of ctx.sourceFiles) {
+		parts.push(`\n=== ${file.relativePath} ===`);
+		parts.push(file.content);
+	}
+	return parts.join("\n");
+}
+const RESET = "\x1B[0m";
+const BOLD = "\x1B[1m";
+const GREEN = "\x1B[32m";
+const CYAN = "\x1B[36m";
+const DIM = "\x1B[2m";
+function formatValue(value) {
+	if (typeof value === "string") return value.length > 300 ? value.slice(0, 300) + "…" : value;
+	return JSON.stringify(value, null, 2);
+}
+function printDiff(diffs) {
+	const separator = "━".repeat(52);
+	for (const diff of diffs) {
+		const label = diff.wasEmpty ? "empty → generated" : "updated";
+		process.stdout.write(`\n${BOLD}${CYAN}${separator}${RESET}\n`);
+		process.stdout.write(`${BOLD}  ${diff.field}${RESET}  ${DIM}(${label})${RESET}\n`);
+		process.stdout.write(`${CYAN}${separator}${RESET}\n`);
+		const lines = formatValue(diff.proposed).split("\n");
+		for (const line of lines) process.stdout.write(`${GREEN}  ${line}${RESET}\n`);
+	}
+	process.stdout.write("\n");
+}
+const FILL_PROMPTS = {
+	analysis: {
+		system: `You are a software engineering analyst. Given a feature.json and the feature's source code, write a clear analysis section. Cover: what the code does architecturally, key patterns used, and why they were likely chosen. Be specific — name actual functions, modules, and techniques visible in the code. Write in first-person technical prose, 150-300 words. Return only the analysis text, no JSON wrapper, no markdown heading.`,
+		userSuffix: "Write the analysis field for this feature."
+	},
+	decisions: {
+		system: `You are a software engineering analyst. Given a feature.json and source code, extract 2-4 key technical decisions evident from the code. For each: what was decided (concrete), why (rationale from code evidence), what alternatives were likely considered.
+
+Return ONLY a valid JSON array — no other text, no markdown fences:
+[
+  {
+    "decision": "string",
+    "rationale": "string",
+    "alternativesConsidered": ["string"],
+    "date": null
+  }
+]`,
+		userSuffix: "Extract the key technical decisions from this feature."
+	},
+	implementation: {
+		system: `You are a software engineering analyst. Given a feature.json and source code, write concise implementation notes. Cover: the main components and their roles, how data flows through the feature, and any non-obvious patterns or constraints. 100-200 words. Return only the text, no JSON wrapper, no heading.`,
+		userSuffix: "Write the implementation field for this feature."
+	},
+	knownLimitations: {
+		system: `You are a software engineering analyst. Identify 2-4 known limitations, trade-offs, or tech-debt items visible in this code. Look for TODOs, FIXMEs, missing error handling, overly complex patterns, or performance gaps.
+
+Return ONLY a valid JSON array of strings — no other text:
+["limitation 1", "limitation 2"]`,
+		userSuffix: "List the known limitations visible in this feature."
+	},
+	tags: {
+		system: `You are a software engineering analyst. Generate 3-6 tags from the domain language in this code. Lowercase, single words or hyphenated. Reflect the actual domain, not generic terms like "code" or "feature".
+
+Return ONLY a valid JSON array of strings — no other text:
+["tag1", "tag2", "tag3"]`,
+		userSuffix: "Generate tags for this feature."
+	},
+	annotations: {
+		system: `You are a software engineering analyst. Identify 1-3 significant annotations worth capturing — warnings, lessons, tech debt, or breaking-change risks visible in the code.
+
+Return ONLY a valid JSON array — no other text:
+[
+  {
+    "id": "auto-1",
+    "author": "lac fill",
+    "date": "${(/* @__PURE__ */ new Date()).toISOString().split("T")[0]}",
+    "type": "tech-debt",
+    "body": "string"
+  }
+]`,
+		userSuffix: "Generate annotations for this feature."
+	},
+	successCriteria: {
+		system: `You are a software engineering analyst. Write a plain-language success criteria statement for this feature — "how do we know it's done and working?" Be specific and testable. 1-3 sentences. Return only the text, no JSON wrapper, no heading.`,
+		userSuffix: "Write the success criteria for this feature."
+	},
+	domain: {
+		system: `You are a software engineering analyst. Identify the primary technical domain for this feature from its code and problem statement. Return a single lowercase word or short hyphenated phrase (e.g. "auth", "payments", "notifications", "data-pipeline"). Return only the domain value — nothing else.`,
+		userSuffix: "Identify the domain for this feature."
+	}
+};
+const JSON_FIELDS = new Set([
+	"decisions",
+	"knownLimitations",
+	"tags",
+	"annotations"
+]);
+const ALL_FILLABLE_FIELDS = [
+	"analysis",
+	"decisions",
+	"implementation",
+	"knownLimitations",
+	"tags",
+	"successCriteria",
+	"domain"
+];
+function getMissingFields(feature) {
+	return ALL_FILLABLE_FIELDS.filter((field) => {
+		const val = feature[field];
+		if (val === void 0 || val === null) return true;
+		if (typeof val === "string") return val.trim().length === 0;
+		if (Array.isArray(val)) return val.length === 0;
+		return false;
+	});
+}
+const GEN_PROMPTS = {
+	component: {
+		system: `You are an expert React/TypeScript developer. You will be given a feature.json describing a feature. Generate a production-quality React component implementing the core UI for this feature. Include TypeScript types, sensible props, and clear comments. Make it maintainable — any developer unfamiliar with this feature should understand it. Return only the component code, no explanation.`,
+		userSuffix: "Generate a React TypeScript component for this feature."
+	},
+	test: {
+		system: `You are an expert software testing engineer. You will be given a feature.json. Generate a comprehensive test suite using Vitest. Use the successCriteria to derive happy-path tests and the knownLimitations to derive edge-case tests. Return only the test code, no explanation.`,
+		userSuffix: "Generate a Vitest test suite for this feature."
+	},
+	migration: {
+		system: `You are an expert database engineer. You will be given a feature.json. Generate a database migration scaffold for the data model this feature implies. Use SQL with clear comments. Include both up (CREATE) and down (DROP) sections. Return only the SQL, no explanation.`,
+		userSuffix: "Generate a database migration for this feature."
+	},
+	docs: {
+		system: `You are a technical writer. You will be given a feature.json. Generate user-facing documentation for this feature. Write it clearly enough that any end user can understand it (not developer-focused). Cover: what it does, how to use it, and known limitations. Use Markdown. Return only the documentation, no explanation.`,
+		userSuffix: "Generate user-facing documentation for this feature."
+	}
+};
+async function fillFeature(options) {
+	const { featureDir, dryRun = false, skipConfirm = false, model = "claude-sonnet-4-6" } = options;
+	const featurePath = path.join(featureDir, "feature.json");
+	let raw;
+	try {
+		raw = fs.readFileSync(featurePath, "utf-8");
+	} catch {
+		throw new Error(`No feature.json found at "${featurePath}"`);
+	}
+	let parsed;
+	try {
+		parsed = JSON.parse(raw);
+	} catch {
+		throw new Error(`Invalid JSON in "${featurePath}"`);
+	}
+	const result = validateFeature(parsed);
+	if (!result.success) throw new Error(`Invalid feature.json: ${result.errors.join(", ")}`);
+	const feature = result.data;
+	const client = createClient();
+	const fieldsToFill = options.fields ? options.fields : getMissingFields(feature);
+	if (fieldsToFill.length === 0) {
+		process$1.stdout.write(`  All fields already filled for ${feature.featureKey}.\n`);
+		return {
+			applied: false,
+			fields: [],
+			patch: {}
+		};
+	}
+	process$1.stdout.write(`\nAnalyzing ${feature.featureKey} (${feature.title})...\n`);
+	const ctx = buildContext(featureDir, feature);
+	const contextStr = contextToString(ctx);
+	process$1.stdout.write(`Reading ${ctx.sourceFiles.length} source file(s)...\n`);
+	process$1.stdout.write(`Generating with ${model}...\n`);
+	const patch = {};
+	const diffs = [];
+	for (const field of fieldsToFill) {
+		const prompt = FILL_PROMPTS[field];
+		if (!prompt) continue;
+		process$1.stdout.write(`  → ${field}...`);
+		try {
+			const rawValue = await generateText(client, prompt.system, `${contextStr}\n\n${prompt.userSuffix}`, model);
+			let value = rawValue.trim();
+			if (JSON_FIELDS.has(field)) try {
+				const jsonStr = rawValue.match(/```(?:json)?\s*([\s\S]*?)```/)?.[1] ?? rawValue;
+				value = JSON.parse(jsonStr.trim());
+			} catch {
+				process$1.stderr.write(`\n  Warning: could not parse JSON for "${field}", storing as string\n`);
+			}
+			patch[field] = value;
+			const existing = feature[field];
+			const wasEmpty = existing === void 0 || existing === null || typeof existing === "string" && existing.trim().length === 0 || Array.isArray(existing) && existing.length === 0;
+			diffs.push({
+				field,
+				wasEmpty,
+				proposed: value
+			});
+			process$1.stdout.write(" done\n");
+		} catch (err) {
+			process$1.stdout.write(" failed\n");
+			process$1.stderr.write(`  Error generating "${field}": ${err instanceof Error ? err.message : String(err)}\n`);
+		}
+	}
+	if (diffs.length === 0) return {
+		applied: false,
+		fields: [],
+		patch: {}
+	};
+	printDiff(diffs);
+	if (dryRun) {
+		process$1.stdout.write("  [dry-run] No changes written.\n\n");
+		return {
+			applied: false,
+			fields: Object.keys(patch),
+			patch
+		};
+	}
+	if (!skipConfirm) {
+		const answer = await askUser("Apply? [Y]es / [n]o / [f]ield-by-field: ");
+		if (answer.toLowerCase() === "n") {
+			process$1.stdout.write("  Cancelled.\n");
+			return {
+				applied: false,
+				fields: Object.keys(patch),
+				patch
+			};
+		}
+		if (answer.toLowerCase() === "f") {
+			const approved = {};
+			for (const [field, value] of Object.entries(patch)) if ((await askUser(`  Apply "${field}"? [Y/n]: `)).toLowerCase() !== "n") approved[field] = value;
+			for (const key of Object.keys(patch)) if (!(key in approved)) delete patch[key];
+			Object.assign(patch, approved);
+		}
+	}
+	const updated = {
+		...parsed,
+		...patch
+	};
+	fs.writeFileSync(featurePath, JSON.stringify(updated, null, 2) + "\n", "utf-8");
+	const count = Object.keys(patch).length;
+	process$1.stdout.write(`\n  ✓ Updated ${feature.featureKey} — ${count} field${count === 1 ? "" : "s"} written.\n\n`);
+	return {
+		applied: true,
+		fields: Object.keys(patch),
+		patch
+	};
+}
+async function genFromFeature(options) {
+	const { featureDir, type, dryRun = false, model = "claude-sonnet-4-6" } = options;
+	const featurePath = path.join(featureDir, "feature.json");
+	let raw;
+	try {
+		raw = fs.readFileSync(featurePath, "utf-8");
+	} catch {
+		throw new Error(`No feature.json found at "${featurePath}"`);
+	}
+	const result = validateFeature(JSON.parse(raw));
+	if (!result.success) throw new Error(`Invalid feature.json: ${result.errors.join(", ")}`);
+	const feature = result.data;
+	const promptConfig = GEN_PROMPTS[type];
+	if (!promptConfig) throw new Error(`Unknown generation type: "${type}". Available: component, test, migration, docs`);
+	const client = createClient();
+	process$1.stdout.write(`\nGenerating ${type} for ${feature.featureKey} (${feature.title})...\n`);
+	process$1.stdout.write(`Model: ${model}\n\n`);
+	const contextStr = contextToString(buildContext(featureDir, feature));
+	const generated = await generateText(client, promptConfig.system, `${contextStr}\n\n${promptConfig.userSuffix}`, model);
+	if (dryRun) {
+		process$1.stdout.write(generated);
+		process$1.stdout.write("\n\n  [dry-run] No file written.\n");
+		return generated;
+	}
+	const outFile = options.outFile ?? path.join(featureDir, `${feature.featureKey}${typeToExt(type)}`);
+	fs.writeFileSync(outFile, generated, "utf-8");
+	process$1.stdout.write(`  ✓ Written to ${outFile}\n\n`);
+	return generated;
+}
+function typeToExt(type) {
+	return {
+		component: ".tsx",
+		test: ".test.ts",
+		migration: ".sql",
+		docs: ".md"
+	}[type] ?? ".txt";
+}
+function askUser(question) {
+	return new Promise((resolve) => {
+		const rl = readline.createInterface({
+			input: process$1.stdin,
+			output: process$1.stdout
+		});
+		rl.question(question, (answer) => {
+			rl.close();
+			resolve(answer.trim() || "y");
+		});
+	});
+}
+
 //#endregion
 //#region ../lac-mcp/src/index.ts
-const workspaceRoot = process.argv[2] ?? process.env.LAC_WORKSPACE ?? process.cwd();
+const workspaceRoot = process$1.argv[2] ?? process$1.env.LAC_WORKSPACE ?? process$1.cwd();
 const server = new Server({
 	name: "lac",
 	version: "1.0.0"
@@ -3939,6 +4369,36 @@ server.setRequestHandler(ListToolsRequestSchema, async () => ({ tools: [
 				description: "Directory to scan (default: workspace root)"
 			} }
 		}
+	},
+	{
+		name: "read_feature_context",
+		description: "Read a feature.json and all surrounding source files. Returns the full context needed to fill missing fields — use this when the user asks you to fill or analyse a feature WITHOUT calling an external AI API (you ARE the AI). After reading, generate the missing fields yourself and call write_feature_fields to save.",
+		inputSchema: {
+			type: "object",
+			properties: { path: {
+				type: "string",
+				description: "Absolute or relative path to the feature folder (contains feature.json)"
+			} },
+			required: ["path"]
+		}
+	},
+	{
+		name: "write_feature_fields",
+		description: "Patch a feature.json with new field values. Use this after read_feature_context — write the fields you generated back to disk.",
+		inputSchema: {
+			type: "object",
+			properties: {
+				path: {
+					type: "string",
+					description: "Absolute or relative path to the feature folder (contains feature.json)"
+				},
+				fields: {
+					type: "object",
+					description: "Key-value pairs to merge into feature.json. Values may be strings, arrays, or objects depending on the field."
+				}
+			},
+			required: ["path", "fields"]
+		}
 	}
 ] }));
 server.setRequestHandler(CallToolRequestSchema, async (request) => {
@@ -4061,6 +4521,77 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
 					text: `${passes.length} passed, ${failures.length} failed — ${results.length} features checked\n\n${lines.join("\n")}`
 				}] };
 			}
+			case "read_feature_context": {
+				const featureDir = resolvePath(String(a.path));
+				const featurePath = path.join(featureDir, "feature.json");
+				let raw;
+				try {
+					raw = fs.readFileSync(featurePath, "utf-8");
+				} catch {
+					return {
+						content: [{
+							type: "text",
+							text: `No feature.json found at "${featurePath}"`
+						}],
+						isError: true
+					};
+				}
+				const result = validateFeature(JSON.parse(raw));
+				if (!result.success) return {
+					content: [{
+						type: "text",
+						text: `Invalid feature.json: ${result.errors.join(", ")}`
+					}],
+					isError: true
+				};
+				const feature = result.data;
+				const contextStr = contextToString(buildContext(featureDir, feature));
+				const missingFields = getMissingFields(feature);
+				const fieldInstructions = missingFields.map((field) => {
+					const prompt = FILL_PROMPTS[field];
+					const isJson = JSON_FIELDS.has(field);
+					return `### ${field}\n${prompt.system}\n${prompt.userSuffix}\n${isJson ? "(Return valid JSON for this field)" : "(Return plain text for this field)"}`;
+				}).join("\n\n");
+				return { content: [{
+					type: "text",
+					text: `${missingFields.length === 0 ? "All fillable fields are already populated. No generation needed." : `## Missing fields to fill (${missingFields.join(", ")})\n\nFor each field below, generate the value described, then call write_feature_fields with all generated values.\n\n${fieldInstructions}`}\n\n## Context\n\n${contextStr}`
+				}] };
+			}
+			case "write_feature_fields": {
+				const featureDir = resolvePath(String(a.path));
+				const featurePath = path.join(featureDir, "feature.json");
+				let raw;
+				try {
+					raw = fs.readFileSync(featurePath, "utf-8");
+				} catch {
+					return {
+						content: [{
+							type: "text",
+							text: `No feature.json found at "${featurePath}"`
+						}],
+						isError: true
+					};
+				}
+				const existing = JSON.parse(raw);
+				const fields = a.fields;
+				if (!fields || typeof fields !== "object" || Array.isArray(fields)) return {
+					content: [{
+						type: "text",
+						text: "fields must be a JSON object"
+					}],
+					isError: true
+				};
+				const updated = {
+					...existing,
+					...fields
+				};
+				fs.writeFileSync(featurePath, JSON.stringify(updated, null, 2) + "\n", "utf-8");
+				const writtenKeys = Object.keys(fields);
+				return { content: [{
+					type: "text",
+					text: `✓ Wrote ${writtenKeys.length} field(s) to ${featurePath}: ${writtenKeys.join(", ")}`
+				}] };
+			}
 			default: return { content: [{
 				type: "text",
 				text: `Unknown tool: ${name}`
@@ -4146,11 +4677,11 @@ function statusIcon(status) {
 async function main() {
 	const transport = new StdioServerTransport();
 	await server.connect(transport);
-	process.stderr.write(`lac MCP server running (workspace: ${workspaceRoot})\n`);
+	process$1.stderr.write(`lac MCP server running (workspace: ${workspaceRoot})\n`);
 }
 main().catch((err) => {
-	process.stderr.write(`Fatal: ${err instanceof Error ? err.message : String(err)}\n`);
-	process.exit(1);
+	process$1.stderr.write(`Fatal: ${err instanceof Error ? err.message : String(err)}\n`);
+	process$1.exit(1);
 });
 
 //#endregion