compmark-vue 0.2.5 → 0.3.0

package/dist/cli.mjs

@@ -1,7 +1,360 @@
 #!/usr/bin/env node
-import { existsSync, readFileSync, writeFileSync } from "node:fs";
-import { join, resolve } from "node:path";
-import { compileScript, parse } from "@vue/compiler-sfc";
+import { defineCommand, runMain } from "citty";
+import { existsSync, mkdirSync, readFileSync, statSync, watch, writeFileSync } from "node:fs";
+import { dirname, join, resolve } from "node:path";
+import { glob } from "tinyglobby";
+import { babelParse, compileScript, parse } from "@vue/compiler-sfc";
+//#region src/discovery.ts
+async function discoverFiles(inputs, ignore) {
+	const baseIgnore = ["**/node_modules/**"];
+	const userIgnore = (ignore ?? []).map(normalizeIgnorePattern);
+	const allIgnore = [...baseIgnore, ...userIgnore];
+	const found = /* @__PURE__ */ new Set();
+	for (const input of inputs) {
+		const resolved = resolve(input);
+		if (input.endsWith(".vue") && existsSync(resolved)) found.add(resolved);
+		else if (isDirectory$1(resolved)) {
+			const files = await glob("**/*.vue", {
+				cwd: resolved,
+				absolute: true,
+				ignore: allIgnore
+			});
+			for (const f of files) found.add(f);
+		} else {
+			const files = await glob(input, {
+				absolute: true,
+				ignore: allIgnore
+			});
+			for (const f of files) found.add(f);
+		}
+	}
+	return [...found].sort();
+}
+function isDirectory$1(path) {
+	try {
+		return statSync(path).isDirectory();
+	} catch {
+		return false;
+	}
+}
+function normalizeIgnorePattern(pattern) {
+	if (pattern.includes("*") || pattern.includes("/")) return pattern;
+	return `**/${pattern}/**`;
+}
+//#endregion
+//#region src/resolver.ts
+function resolveImportPath(importSource, sfcDir) {
+	try {
+		if (!importSource.startsWith(".") && !importSource.startsWith("@/") && !importSource.startsWith("~/")) return null;
+		if (importSource.startsWith("./") || importSource.startsWith("../")) return tryResolveFile(resolve(sfcDir, importSource));
+		const tsconfig = findTsConfig(sfcDir);
+		if (!tsconfig) return null;
+		const { paths, baseUrl } = readTsConfigPaths(tsconfig);
+		if (!paths) return null;
+		const configDir = dirname(tsconfig);
+		const resolvedBaseUrl = baseUrl ? resolve(configDir, baseUrl) : configDir;
+		for (const [pattern, targets] of Object.entries(paths)) {
+			const prefix = pattern.replace(/\*$/, "");
+			if (!importSource.startsWith(prefix)) continue;
+			const remainder = importSource.slice(prefix.length);
+			for (const target of targets) {
+				const result = tryResolveFile(resolve(resolvedBaseUrl, target.replace(/\*$/, "") + remainder));
+				if (result) return result;
+			}
+		}
+		return null;
+	} catch {
+		return null;
+	}
+}
+function tryResolveFile(basePath) {
+	if (existsSync(basePath) && !isDirectory(basePath)) return basePath;
+	for (const ext of [".ts", ".js"]) {
+		const candidate = basePath + ext;
+		if (existsSync(candidate)) return candidate;
+	}
+	for (const ext of ["/index.ts", "/index.js"]) {
+		const candidate = basePath + ext;
+		if (existsSync(candidate)) return candidate;
+	}
+	return null;
+}
+function isDirectory(filePath) {
+	try {
+		return statSync(filePath).isDirectory();
+	} catch {
+		return false;
+	}
+}
+function findTsConfig(startDir) {
+	let dir = resolve(startDir);
+	const root = resolve("/");
+	while (dir !== root) {
+		const tsconfig = join(dir, "tsconfig.json");
+		if (existsSync(tsconfig)) return tsconfig;
+		const jsconfig = join(dir, "jsconfig.json");
+		if (existsSync(jsconfig)) return jsconfig;
+		const parent = dirname(dir);
+		if (parent === dir) break;
+		dir = parent;
+	}
+	return null;
+}
+function readTsConfigPaths(configPath) {
+	try {
+		const content = JSON.parse(readFileSync(configPath, "utf-8"));
+		let paths = content.compilerOptions?.paths ?? null;
+		let baseUrl = content.compilerOptions?.baseUrl;
+		if (content.extends) {
+			const parentPath = resolve(dirname(configPath), content.extends);
+			const parentConfigFile = parentPath.endsWith(".json") ? parentPath : parentPath + ".json";
+			if (existsSync(parentConfigFile)) try {
+				const parentContent = JSON.parse(readFileSync(parentConfigFile, "utf-8"));
+				const parentPaths = parentContent.compilerOptions?.paths;
+				const parentBaseUrl = parentContent.compilerOptions?.baseUrl;
+				if (!paths && parentPaths) paths = parentPaths;
+				if (!baseUrl && parentBaseUrl) baseUrl = parentBaseUrl;
+			} catch {}
+		}
+		return {
+			paths,
+			baseUrl
+		};
+	} catch {
+		return {
+			paths: null,
+			baseUrl: void 0
+		};
+	}
+}
+function resolveComposableTypes(filePath, exportName, variableNames) {
+	try {
+		const funcNode = findExportedFunction(babelParse(readFileSync(filePath, "utf-8"), {
+			plugins: ["typescript", "jsx"],
+			sourceType: "module"
+		}).program.body, exportName);
+		if (!funcNode) return /* @__PURE__ */ new Map();
+		const body = getFunctionBody(funcNode);
+		if (!body) return /* @__PURE__ */ new Map();
+		const returnProps = findReturnProperties(body);
+		if (!returnProps) return /* @__PURE__ */ new Map();
+		const result = /* @__PURE__ */ new Map();
+		const nameSet = new Set(variableNames);
+		for (const prop of returnProps) {
+			let propName = null;
+			if (prop.type === "ObjectProperty") propName = prop.key.type === "Identifier" ? prop.key.name : prop.key.type === "StringLiteral" ? prop.key.value : null;
+			else if (prop.type === "ObjectMethod") {
+				propName = prop.key.type === "Identifier" ? prop.key.name : null;
+				if (propName && nameSet.has(propName)) result.set(propName, inferFunctionSignature(prop));
+				continue;
+			} else if (prop.type === "SpreadElement") continue;
+			if (!propName || !nameSet.has(propName)) continue;
+			if (prop.type === "ObjectProperty" && prop.shorthand) {
+				const type = traceVariableType(propName, body);
+				result.set(propName, type);
+			} else if (prop.type === "ObjectProperty") {
+				const type = inferType(prop.value);
+				result.set(propName, type);
+			}
+		}
+		return result;
+	} catch {
+		return /* @__PURE__ */ new Map();
+	}
+}
+function findExportedFunction(stmts, exportName) {
+	for (const stmt of stmts) {
+		if (stmt.type === "ExportNamedDeclaration" && stmt.declaration?.type === "FunctionDeclaration" && stmt.declaration.id?.name === exportName) return stmt.declaration;
+		if (stmt.type === "ExportNamedDeclaration" && stmt.declaration?.type === "VariableDeclaration") {
+			for (const decl of stmt.declaration.declarations) if (decl.id.type === "Identifier" && decl.id.name === exportName && decl.init && (decl.init.type === "ArrowFunctionExpression" || decl.init.type === "FunctionExpression")) return decl.init;
+		}
+		if (stmt.type === "ExportDefaultDeclaration" && stmt.declaration.type === "FunctionDeclaration" && stmt.declaration.id?.name === exportName) return stmt.declaration;
+		if (stmt.type === "ExportDefaultDeclaration" && stmt.declaration.type === "FunctionDeclaration" && !stmt.declaration.id) return stmt.declaration;
+		if (stmt.type === "ExportDefaultDeclaration" && (stmt.declaration.type === "ArrowFunctionExpression" || stmt.declaration.type === "FunctionExpression")) return stmt.declaration;
+		if (stmt.type === "FunctionDeclaration" && stmt.id?.name === exportName) {
+			if (stmts.some((s) => s.type === "ExportNamedDeclaration" && !s.declaration && s.specifiers.some((spec) => spec.type === "ExportSpecifier" && (spec.local.type === "Identifier" && spec.local.name === exportName || spec.exported.type === "Identifier" && spec.exported.name === exportName)))) return stmt;
+		}
+		if (stmt.type === "VariableDeclaration") {
+			for (const decl of stmt.declarations) if (decl.id.type === "Identifier" && decl.id.name === exportName && decl.init && (decl.init.type === "ArrowFunctionExpression" || decl.init.type === "FunctionExpression")) {
+				if (stmts.some((s) => s.type === "ExportNamedDeclaration" && !s.declaration && s.specifiers.some((spec) => spec.type === "ExportSpecifier" && (spec.local.type === "Identifier" && spec.local.name === exportName || spec.exported.type === "Identifier" && spec.exported.name === exportName)))) return decl.init;
+			}
+		}
+	}
+	return null;
+}
+function getFunctionBody(node) {
+	if (node.body.type === "BlockStatement") return node.body.body;
+	return null;
+}
+function findReturnProperties(body) {
+	for (let i = body.length - 1; i >= 0; i--) {
+		const stmt = body[i];
+		if (stmt.type === "ReturnStatement" && stmt.argument?.type === "ObjectExpression") return stmt.argument.properties;
+	}
+	return null;
+}
+function traceVariableType(name, body) {
+	for (let i = body.length - 1; i >= 0; i--) {
+		const stmt = body[i];
+		if (stmt.type === "FunctionDeclaration" && stmt.id?.name === name) return inferFunctionSignature(stmt);
+		if (stmt.type === "VariableDeclaration") {
+			for (const decl of stmt.declarations) if (decl.id.type === "Identifier" && decl.id.name === name && decl.init) return inferType(decl.init);
+		}
+	}
+	return "unknown";
+}
+function inferType(node) {
+	if (node.type === "CallExpression" && node.callee.type === "Identifier" && node.callee.name === "ref") {
+		const typeParams = node.typeParameters;
+		if (typeParams?.params?.length > 0) return `Ref<${resolveTypeAnnotation(typeParams.params[0])}>`;
+		const arg = node.arguments[0];
+		if (!arg) return "Ref<unknown>";
+		return `Ref<${inferLiteralType(arg)}>`;
+	}
+	if (node.type === "CallExpression" && node.callee.type === "Identifier" && node.callee.name === "computed") return "ComputedRef";
+	if (node.type === "CallExpression" && node.callee.type === "Identifier" && node.callee.name === "reactive") return "Object";
+	if (node.type === "ArrowFunctionExpression" || node.type === "FunctionExpression") return inferFunctionSignature(node);
+	if (node.type === "CallExpression" && node.callee.type === "Identifier" && /^use[A-Z]/.test(node.callee.name)) return "unknown";
+	return inferLiteralType(node);
+}
+function inferLiteralType(node) {
+	switch (node.type) {
+		case "NumericLiteral": return "number";
+		case "StringLiteral": return "string";
+		case "BooleanLiteral": return "boolean";
+		case "NullLiteral": return "null";
+		case "TemplateLiteral": return "string";
+		case "ArrayExpression": return "Array";
+		case "ObjectExpression": return "Object";
+		default: return "unknown";
+	}
+}
+function inferFunctionSignature(node) {
+	return `(${extractParams(node.params ?? [])}) => ${extractReturnType(node)}`;
+}
+function extractParams(params) {
+	return params.map((param) => {
+		if (param.type === "Identifier") {
+			const annotation = param.typeAnnotation?.typeAnnotation;
+			if (annotation) return `${param.name}: ${resolveTypeAnnotation(annotation)}`;
+			return param.name;
+		}
+		if (param.type === "AssignmentPattern") {
+			const left = param.left;
+			if (left.type === "Identifier") {
+				const annotation = left.typeAnnotation?.typeAnnotation;
+				if (annotation) return `${left.name}: ${resolveTypeAnnotation(annotation)}`;
+				return left.name;
+			}
+			return "arg";
+		}
+		if (param.type === "RestElement") {
+			const arg = param.argument;
+			if (arg.type === "Identifier") {
+				const annotation = arg.typeAnnotation?.typeAnnotation;
+				if (annotation) return `...${arg.name}: ${resolveTypeAnnotation(annotation)}`;
+				return `...${arg.name}`;
+			}
+			return "...args";
+		}
+		if (param.type === "ObjectPattern") return "options";
+		if (param.type === "ArrayPattern") return "args";
+		return "arg";
+	}).join(", ");
+}
+function extractReturnType(node) {
+	const annotation = node.returnType?.typeAnnotation ?? node.typeAnnotation?.typeAnnotation;
+	let baseType;
+	if (annotation) baseType = resolveTypeAnnotation(annotation);
+	else baseType = "void";
+	if (node.async && baseType !== "void") return `Promise<${baseType}>`;
+	if (node.async) return "Promise<void>";
+	return baseType;
+}
+function resolveTypeAnnotation(node) {
+	if (!node) return "unknown";
+	switch (node.type) {
+		case "TSStringKeyword": return "string";
+		case "TSNumberKeyword": return "number";
+		case "TSBooleanKeyword": return "boolean";
+		case "TSVoidKeyword": return "void";
+		case "TSAnyKeyword": return "any";
+		case "TSNullKeyword": return "null";
+		case "TSUndefinedKeyword": return "undefined";
+		case "TSObjectKeyword": return "object";
+		case "TSNeverKeyword": return "never";
+		case "TSUnknownKeyword": return "unknown";
+		case "TSTypeReference": {
+			const name = node.typeName?.type === "Identifier" ? node.typeName.name : node.typeName?.type === "TSQualifiedName" ? `${node.typeName.left?.name ?? ""}.${node.typeName.right?.name ?? ""}` : "unknown";
+			if (node.typeParameters?.params?.length > 0) return `${name}<${node.typeParameters.params.map((p) => resolveTypeAnnotation(p)).join(", ")}>`;
+			return name;
+		}
+		case "TSUnionType": return node.types.map((t) => resolveTypeAnnotation(t)).join(" | ");
+		case "TSIntersectionType": return node.types.map((t) => resolveTypeAnnotation(t)).join(" & ");
+		case "TSArrayType": return `${resolveTypeAnnotation(node.elementType)}[]`;
+		case "TSLiteralType":
+			if (node.literal.type === "StringLiteral") return `'${node.literal.value}'`;
+			if (node.literal.type === "NumericLiteral") return String(node.literal.value);
+			if (node.literal.type === "BooleanLiteral") return String(node.literal.value);
+			return "unknown";
+		case "TSFunctionType": return "Function";
+		case "TSTupleType": return `[${(node.elementTypes ?? []).map((t) => resolveTypeAnnotation(t)).join(", ")}]`;
+		case "TSParenthesizedType": return resolveTypeAnnotation(node.typeAnnotation);
+		case "TSTypeLiteral": return "object";
+		default: return "unknown";
+	}
+}
+//#endregion
+//#region src/type-resolver.ts
+function resolveImportedPropsType(typeName, importMap, sfcDir) {
+	const source = importMap.get(typeName);
+	if (!source) return null;
+	const resolvedPath = resolveImportPath(source, sfcDir);
+	if (!resolvedPath) return null;
+	try {
+		return findExportedType(babelParse(readFileSync(resolvedPath, "utf-8"), {
+			plugins: ["typescript"],
+			sourceType: "module"
+		}).program.body, typeName, 0);
+	} catch {
+		return null;
+	}
+}
+function findExportedType(stmts, typeName, depth) {
+	if (depth > 5) return null;
+	for (const stmt of stmts) {
+		if (stmt.type === "ExportNamedDeclaration" && stmt.declaration?.type === "TSInterfaceDeclaration" && stmt.declaration.id.name === typeName) return resolveInterfaceMembers(stmt.declaration, stmts, depth);
+		if (stmt.type === "ExportNamedDeclaration" && stmt.declaration?.type === "TSTypeAliasDeclaration" && stmt.declaration.id.name === typeName && stmt.declaration.typeAnnotation.type === "TSTypeLiteral") return { members: [...stmt.declaration.typeAnnotation.members] };
+	}
+	if (hasNamedExport(stmts, typeName)) return findTypeInFile(stmts, typeName, depth);
+	return null;
+}
+function findTypeInFile(stmts, typeName, depth) {
+	if (depth > 5) return null;
+	for (const stmt of stmts) {
+		if (stmt.type === "ExportNamedDeclaration" && stmt.declaration?.type === "TSInterfaceDeclaration" && stmt.declaration.id.name === typeName) return resolveInterfaceMembers(stmt.declaration, stmts, depth);
+		if (stmt.type === "ExportNamedDeclaration" && stmt.declaration?.type === "TSTypeAliasDeclaration" && stmt.declaration.id.name === typeName && stmt.declaration.typeAnnotation.type === "TSTypeLiteral") return { members: [...stmt.declaration.typeAnnotation.members] };
+		if (stmt.type === "TSInterfaceDeclaration" && stmt.id.name === typeName) return resolveInterfaceMembers(stmt, stmts, depth);
+		if (stmt.type === "TSTypeAliasDeclaration" && stmt.id.name === typeName && stmt.typeAnnotation.type === "TSTypeLiteral") return { members: [...stmt.typeAnnotation.members] };
+	}
+	return null;
+}
+function resolveInterfaceMembers(decl, stmts, depth) {
+	const members = [];
+	if (decl.extends) for (const ext of decl.extends) {
+		const parentName = ext.expression?.type === "Identifier" ? ext.expression.name : null;
+		if (parentName) {
+			const parent = findTypeInFile(stmts, parentName, depth + 1);
+			if (parent) members.push(...parent.members);
+		}
+	}
+	members.push(...decl.body.body);
+	return { members };
+}
+function hasNamedExport(stmts, name) {
+	return stmts.some((s) => s.type === "ExportNamedDeclaration" && !s.declaration && s.specifiers.some((spec) => spec.type === "ExportSpecifier" && (spec.local.type === "Identifier" && spec.local.name === name || spec.exported.type === "Identifier" && spec.exported.name === name)));
+}
+//#endregion
 //#region src/parser.ts
 function parseJSDocTags(comments) {
 	const result = { description: "" };
@@ -22,35 +375,61 @@ function parseJSDocTags(comments) {
 	result.description = descLines.join(" ");
 	return result;
 }
-function parseSFC(source, filename) {
+function parseSFC(source, filename, sfcDir) {
 	const doc = {
 		name: filename.replace(/\.vue$/, "").split("/").pop() ?? "Unknown",
 		props: [],
 		emits: []
 	};
-	const { descriptor } = parse(source, { filename });
+	const fullPath = sfcDir ? `${sfcDir}/${filename}` : filename;
+	const { descriptor } = parse(source, { filename: fullPath });
+	doc.scriptSetup = !!descriptor.scriptSetup;
 	if (descriptor.template?.ast) {
 		const templateSlots = extractTemplateSlots(descriptor.template.ast);
 		if (templateSlots.length > 0) doc.slots = templateSlots;
 	}
 	if (!descriptor.scriptSetup && !descriptor.script) return doc;
-	const compiled = compileScript(descriptor, { id: filename });
+	let compiled;
+	try {
+		compiled = compileScript(descriptor, {
+			id: fullPath,
+			fs: {
+				fileExists: (file) => existsSync(file),
+				readFile: (file) => {
+					try {
+						return readFileSync(file, "utf-8");
+					} catch {
+						return;
+					}
+				}
+			}
+		});
+	} catch {
+		return doc;
+	}
 	const componentJSDoc = extractComponentJSDoc(compiled.scriptSetupAst ?? compiled.scriptAst ?? []);
 	doc.description = componentJSDoc.description;
 	doc.internal = componentJSDoc.internal;
 	const setupAst = compiled.scriptSetupAst;
 	if (setupAst) {
 		const scriptSource = descriptor.scriptSetup?.content ?? compiled.content;
+		const importMap = buildImportMap(setupAst);
 		for (const stmt of setupAst) {
 			const calls = extractDefineCalls(stmt);
 			for (const { callee, args, leadingComments, typeParams, defaultsArg } of calls) if (callee === "defineProps" && args[0]?.type === "ObjectExpression") doc.props = extractProps(args[0], scriptSource);
 			else if (callee === "defineProps" && typeParams?.params[0]?.type === "TSTypeLiteral") doc.props = extractTypeProps(typeParams.params[0], defaultsArg, scriptSource);
-			else if (callee === "defineEmits" && args[0]?.type === "ArrayExpression") doc.emits = extractEmits(args[0], leadingComments);
+			else if (callee === "defineProps" && typeParams?.params[0]?.type === "TSTypeReference") {
+				const typeName = typeParams.params[0].typeName?.name;
+				if (typeName && sfcDir) {
+					const resolved = resolveImportedPropsType(typeName, importMap, sfcDir);
+					if (resolved) doc.props = extractTypeProps(resolved, defaultsArg, scriptSource);
+				}
+			} else if (callee === "defineEmits" && args[0]?.type === "ArrayExpression") doc.emits = extractEmits(args[0], leadingComments);
 			else if (callee === "defineEmits" && typeParams?.params[0]?.type === "TSTypeLiteral") doc.emits = extractTypeEmits(typeParams.params[0]);
 			else if (callee === "defineSlots" && typeParams?.params[0]?.type === "TSTypeLiteral") doc.slots = extractTypeSlots(typeParams.params[0]);
 			else if (callee === "defineExpose" && args[0]?.type === "ObjectExpression") doc.exposes = extractExposes(args[0], scriptSource);
 		}
-		doc.composables = extractComposables(setupAst);
+		doc.composables = extractComposables(setupAst, importMap, sfcDir);
 	}
 	const scriptAst = compiled.scriptAst;
 	if (scriptAst && doc.props.length === 0 && doc.emits.length === 0) {
@@ -331,26 +710,94 @@ function extractExposes(obj, _source) {
 	}
 	return exposes;
 }
-function extractComposables(ast) {
+function buildImportMap(ast) {
+	const map = /* @__PURE__ */ new Map();
+	for (const stmt of ast) if (stmt.type === "ImportDeclaration") {
+		for (const spec of stmt.specifiers ?? []) if (spec.type === "ImportSpecifier" || spec.type === "ImportDefaultSpecifier") map.set(spec.local.name, stmt.source.value);
+	}
+	return map;
+}
+function extractVariablesFromPattern(decl) {
+	const id = decl.id;
+	if (!id) return [];
+	if (id.type === "Identifier") {
+		const v = { name: id.name };
+		if (id.typeAnnotation?.typeAnnotation) v.type = resolveTypeString(id.typeAnnotation.typeAnnotation);
+		return [v];
+	}
+	if (id.type === "ObjectPattern") {
+		const vars = [];
+		const typeAnnotation = id.typeAnnotation?.typeAnnotation;
+		const typeMembers = typeAnnotation?.type === "TSTypeLiteral" ? typeAnnotation.members : null;
+		for (const prop of id.properties) if (prop.type === "RestElement") {
+			const name = prop.argument?.name ?? "rest";
+			vars.push({ name });
+		} else if (prop.type === "ObjectProperty") {
+			const name = prop.value?.type === "Identifier" ? prop.value.name : prop.value?.type === "AssignmentPattern" && prop.value.left?.type === "Identifier" ? prop.value.left.name : prop.key?.type === "Identifier" ? prop.key.name : "";
+			if (!name) continue;
+			const v = { name };
+			if (typeMembers) {
+				const keyName = prop.key?.type === "Identifier" ? prop.key.name : "";
+				for (const member of typeMembers) if (member.type === "TSPropertySignature" && member.key?.type === "Identifier" && member.key.name === keyName && member.typeAnnotation?.typeAnnotation) {
+					v.type = resolveTypeString(member.typeAnnotation.typeAnnotation);
+					break;
+				}
+			}
+			vars.push(v);
+		}
+		return vars;
+	}
+	if (id.type === "ArrayPattern") {
+		const vars = [];
+		for (const el of id.elements) {
+			if (!el) continue;
+			if (el.type === "Identifier") vars.push({ name: el.name });
+			else if (el.type === "RestElement" && el.argument?.type === "Identifier") vars.push({ name: el.argument.name });
+			else if (el.type === "AssignmentPattern" && el.left?.type === "Identifier") vars.push({ name: el.left.name });
+		}
+		return vars;
+	}
+	return [];
+}
+function extractComposables(ast, importMap, sfcDir) {
 	const seen = /* @__PURE__ */ new Set();
 	const composables = [];
 	for (const stmt of ast) {
-		const callNames = extractComposableCallNames(stmt);
-		for (const name of callNames) if (!seen.has(name)) {
-			seen.add(name);
-			composables.push({ name });
+		if (stmt.type === "ExpressionStatement" && stmt.expression.type === "CallExpression" && stmt.expression.callee.type === "Identifier" && /^use[A-Z]/.test(stmt.expression.callee.name)) {
+			const name = stmt.expression.callee.name;
+			if (!seen.has(name)) {
+				seen.add(name);
+				composables.push({
+					name,
+					source: importMap.get(name),
+					variables: []
+				});
+			}
+		}
+		if (stmt.type === "VariableDeclaration") {
+			for (const decl of stmt.declarations) if (decl.init?.type === "CallExpression" && decl.init.callee.type === "Identifier" && /^use[A-Z]/.test(decl.init.callee.name)) {
+				const name = decl.init.callee.name;
+				if (seen.has(name)) continue;
+				seen.add(name);
+				const variables = extractVariablesFromPattern(decl);
+				const source = importMap.get(name);
+				if (variables.some((v) => !v.type) && sfcDir && source) {
+					const resolvedPath = resolveImportPath(source, sfcDir);
+					if (resolvedPath) {
+						const typeMap = resolveComposableTypes(resolvedPath, name, variables.filter((v) => !v.type).map((v) => v.name));
+						for (const v of variables) if (!v.type && typeMap.has(v.name)) v.type = typeMap.get(v.name);
+					}
+				}
+				composables.push({
+					name,
+					source,
+					variables
+				});
+			}
 		}
 	}
 	return composables;
 }
-function extractComposableCallNames(stmt) {
-	const names = [];
-	if (stmt.type === "ExpressionStatement" && stmt.expression.type === "CallExpression" && stmt.expression.callee.type === "Identifier" && /^use[A-Z]/.test(stmt.expression.callee.name)) names.push(stmt.expression.callee.name);
-	if (stmt.type === "VariableDeclaration") {
-		for (const decl of stmt.declarations) if (decl.init?.type === "CallExpression" && decl.init.callee.type === "Identifier" && /^use[A-Z]/.test(decl.init.callee.name)) names.push(decl.init.callee.name);
-	}
-	return names;
-}
 function extractTemplateSlots(templateAst) {
 	const slots = [];
 	walkTemplate(templateAst.children ?? [], slots);
@@ -448,9 +895,13 @@ function stringifyDefault(node, source) {
 function esc(value) {
 	return value.replaceAll("|", "\\|");
 }
+function escHtml(value) {
+	return value.replaceAll("<", "&lt;").replaceAll(">", "&gt;");
+}
 function generateMarkdown(doc) {
 	const sections = [`# ${doc.name}`];
 	if (doc.description) sections.push("", doc.description);
+	if (doc.scriptSetup) sections.push("", "**Note:** Uses `<script setup>` syntax.");
 	const hasProps = doc.props.length > 0;
 	const hasEmits = doc.emits.length > 0;
 	const hasSlots = (doc.slots?.length ?? 0) > 0;
@@ -518,49 +969,273 @@ function generateMarkdown(doc) {
 		}
 	}
 	if (hasComposables) {
-		sections.push("", "## Composables Used", "");
-		for (const c of doc.composables) sections.push(`- \`${c.name}\``);
+		sections.push("", "## Composables Used");
+		for (const c of doc.composables) {
+			sections.push("", `### \`${c.name}\``);
+			if (c.source && (c.source.startsWith(".") || c.source.startsWith("@/"))) sections.push("", `*Source: \`${c.source}\`*`);
+			if (c.variables.length === 0) sections.push("", "Called for side effects.");
+			else if (!c.variables.some((v) => v.type) && c.variables.length <= 3) {
+				const vars = c.variables.map((v) => `\`${v.name}\``).join(", ");
+				sections.push("", `**Returns:** ${vars}`);
+			} else {
+				sections.push("");
+				sections.push("| Variable | Type |");
+				sections.push("| --- | --- |");
+				for (const v of c.variables) {
+					const type = v.type ? escHtml(esc(v.type)) : "-";
+					sections.push(`| ${esc(v.name)} | ${type} |`);
+				}
+			}
+		}
 	}
 	return sections.join("\n") + "\n";
 }
+function adjustHeadingLevel(md, increment) {
+	return md.replace(/^(#{1,6})\s/gm, (_, hashes) => {
+		const newLevel = Math.min(hashes.length + increment, 6);
+		return "#".repeat(newLevel) + " ";
+	});
+}
 //#endregion
 //#region src/index.ts
 function parseComponent(filePath) {
 	const abs = resolve(filePath);
-	return parseSFC(readFileSync(abs, "utf-8"), abs.split("/").pop() ?? "Unknown.vue");
+	return parseSFC(readFileSync(abs, "utf-8"), abs.split("/").pop() ?? "Unknown.vue", abs.substring(0, abs.lastIndexOf("/")));
 }
 //#endregion
-//#region src/cli.ts
-const filePath = process.argv[2];
-if (!filePath) {
-	console.error("Usage: compmark <path-to-component.vue>");
-	process.exit(1);
-}
-if (!filePath.endsWith(".vue")) {
-	console.error(`Error: Expected a .vue file, got: ${filePath}`);
-	process.exit(1);
-}
-const abs = resolve(filePath);
-if (!existsSync(abs)) {
-	console.error(`Error: File not found: ${filePath}`);
-	process.exit(1);
-}
-try {
-	const doc = parseComponent(abs);
-	if (doc.internal) {
-		const name = abs.split("/").pop() ?? filePath;
-		console.log(`Skipped ${name} (marked @internal)`);
+//#region src/runner.ts
+function processFiles(filePaths, options) {
+	const summary = {
+		documented: 0,
+		skipped: 0,
+		errors: 0,
+		files: [],
+		errorDetails: []
+	};
+	for (const filePath of filePaths) try {
+		const doc = parseComponent(filePath);
+		if (doc.internal) {
+			summary.skipped++;
+			if (!options.silent) {
+				const name = filePath.split("/").pop() ?? filePath;
+				console.log(`  Skipped ${name} (marked @internal)`);
+			}
+			continue;
+		}
+		summary.documented++;
+		summary.files.push({
+			path: filePath,
+			doc
+		});
+	} catch (err) {
+		summary.errors++;
+		const name = filePath.split("/").pop() ?? filePath;
+		const message = err instanceof Error ? err.message : String(err);
+		summary.errorDetails.push({
+			path: filePath,
+			error: message
+		});
+		if (!options.silent) console.warn(`  Warning: Could not parse ${name}: ${message}`);
+	}
+	return summary;
+}
+//#endregion
+//#region src/output.ts
+function writeIndividualMarkdown(results, outDir, silent) {
+	mkdirSync(outDir, { recursive: true });
+	const usedNames = /* @__PURE__ */ new Map();
+	for (const { doc } of results) {
+		const baseName = doc.name;
+		const count = usedNames.get(baseName) ?? 0;
+		usedNames.set(baseName, count + 1);
+		const fileName = count === 0 ? baseName : `${baseName}-${count + 1}`;
+		const md = generateMarkdown(doc);
+		writeFileSync(join(outDir, `${fileName}.md`), md, "utf-8");
+		if (!silent) console.log(`  Created ${fileName}.md`);
+	}
+}
+function writeJoinedMarkdown(results, outDir, silent) {
+	mkdirSync(outDir, { recursive: true });
+	const sections = [];
+	sections.push("# Component Documentation");
+	sections.push("");
+	sections.push(`*Generated: ${(/* @__PURE__ */ new Date()).toISOString()}*`);
+	sections.push("");
+	sections.push("## Table of Contents");
+	sections.push("");
+	for (const { doc } of results) {
+		const anchor = doc.name.toLowerCase().replace(/[^a-z0-9-]/g, "-");
+		sections.push(`- [${doc.name}](#${anchor})`);
+	}
+	for (const { doc } of results) {
+		const adjusted = adjustHeadingLevel(generateMarkdown(doc), 1);
+		sections.push("");
+		sections.push("---");
+		sections.push("");
+		sections.push(adjusted.trimEnd());
+	}
+	writeFileSync(join(outDir, "components.md"), sections.join("\n") + "\n", "utf-8");
+	if (!silent) console.log(`  Created components.md`);
+}
+function writeJSON(results, outDir, joined, silent) {
+	mkdirSync(outDir, { recursive: true });
+	if (joined) {
+		const data = {
+			generated: (/* @__PURE__ */ new Date()).toISOString(),
+			components: results.map((r) => r.doc)
+		};
+		writeFileSync(join(outDir, "components.json"), JSON.stringify(data, null, 2) + "\n", "utf-8");
+		if (!silent) console.log(`  Created components.json`);
+	} else {
+		const usedNames = /* @__PURE__ */ new Map();
+		for (const { doc } of results) {
+			const baseName = doc.name;
+			const count = usedNames.get(baseName) ?? 0;
+			usedNames.set(baseName, count + 1);
+			const fileName = count === 0 ? baseName : `${baseName}-${count + 1}`;
+			writeFileSync(join(outDir, `${fileName}.json`), JSON.stringify(doc, null, 2) + "\n", "utf-8");
+			if (!silent) console.log(`  Created ${fileName}.json`);
+		}
+	}
+}
+//#endregion
+//#region src/watcher.ts
+function startWatcher(inputs, ignore, rebuild) {
+	const roots = /* @__PURE__ */ new Set();
+	for (const input of inputs) if (input.endsWith(".vue")) roots.add(dirname(resolve(input)));
+	else roots.add(resolve(input));
+	let timer = null;
+	const debounce = () => {
+		if (timer) clearTimeout(timer);
+		timer = setTimeout(() => {
+			console.log("[watch] Rebuilding...");
+			try {
+				rebuild();
+			} catch (err) {
+				const msg = err instanceof Error ? err.message : String(err);
+				console.error(`[watch] Error: ${msg}`);
+			}
+			console.log("[watch] Done.");
+		}, 300);
+	};
+	const watchers = [];
+	for (const root of roots) try {
+		const watcher = watch(root, { recursive: true }, (_event, filename) => {
+			if (!filename || !filename.endsWith(".vue")) return;
+			if (ignore.some((pattern) => filename.includes(pattern))) return;
+			debounce();
+		});
+		watchers.push(watcher);
+	} catch {
+		console.warn(`[watch] Could not watch: ${root}`);
+	}
+	console.log(`[watch] Watching ${roots.size} root(s) for changes...`);
+	process.on("SIGINT", () => {
+		for (const w of watchers) w.close();
 		process.exit(0);
+	});
+}
+//#endregion
+//#region src/cli.ts
+const main = defineCommand({
+	meta: {
+		name: "compmark",
+		version: "0.3.0",
+		description: "Auto-generate Markdown documentation from Vue 3 SFCs"
+	},
+	args: {
+		out: {
+			type: "string",
+			description: "Output directory",
+			default: "."
+		},
+		ignore: {
+			type: "string",
+			description: "Comma-separated ignore patterns"
+		},
+		join: {
+			type: "boolean",
+			description: "Combine output into a single file"
+		},
+		format: {
+			type: "string",
+			description: "Output format: md | json",
+			default: "md"
+		},
+		watch: {
+			type: "boolean",
+			description: "Watch for changes and rebuild"
+		},
+		silent: {
+			type: "boolean",
+			description: "Suppress non-error output"
+		}
+	},
+	async run({ args }) {
+		const inputPaths = collectInputPaths();
+		if (inputPaths.length === 0) {
+			console.error("Error: No input files or directories specified");
+			console.error("Usage: compmark <files/dirs/globs> [options]");
+			process.exit(1);
+		}
+		const format = args.format;
+		if (format !== "md" && format !== "json") {
+			console.error(`Error: Unknown format "${format}". Use "md" or "json".`);
+			process.exit(1);
+		}
+		const ignorePatterns = args.ignore ? args.ignore.split(",").map((s) => s.trim()).filter(Boolean) : [];
+		const silent = args.silent ?? false;
+		const joined = args.join ?? false;
+		const outDir = args.out ?? ".";
+		const rebuild = async () => {
+			const filePaths = await discoverFiles(inputPaths, ignorePatterns);
+			if (filePaths.length === 0) {
+				if (!args.watch) {
+					console.error("Error: No .vue files found");
+					process.exit(1);
+				}
+				console.warn("Warning: No .vue files found");
+				return null;
+			}
+			const summary = processFiles(filePaths, { silent });
+			if (format === "json") writeJSON(summary.files, outDir, joined, silent);
+			else if (joined) writeJoinedMarkdown(summary.files, outDir, silent);
+			else writeIndividualMarkdown(summary.files, outDir, silent);
+			if (!silent) console.log(`✓ ${summary.documented} components documented, ${summary.skipped} skipped, ${summary.errors} errors`);
+			return summary;
+		};
+		const summary = await rebuild();
+		if (args.watch) startWatcher(inputPaths, ignorePatterns, () => {
+			rebuild();
+		});
+		else if (summary && summary.errors > 0) process.exit(1);
+	}
+});
+function collectInputPaths() {
+	const argv = process.argv.slice(2);
+	const paths = [];
+	const flagsWithValue = new Set([
+		"--out",
+		"--ignore",
+		"--format"
+	]);
+	let i = 0;
+	while (i < argv.length) {
+		const arg = argv[i];
+		if (arg === "--") {
+			paths.push(...argv.slice(i + 1));
+			break;
+		}
+		if (flagsWithValue.has(arg)) i += 2;
+		else if (arg.startsWith("--") && arg.includes("=")) i++;
+		else if (arg.startsWith("--")) i++;
+		else {
+			paths.push(arg);
+			i++;
+		}
 	}
-	const md = generateMarkdown(doc);
-	const outFile = `${doc.name}.md`;
-	writeFileSync(join(process.cwd(), outFile), md, "utf-8");
-	console.log(`Created ${outFile}`);
-} catch (err) {
-	const name = abs.split("/").pop() ?? filePath;
-	const reason = err instanceof Error ? err.message : String(err);
-	console.error(`Error: Could not parse ${name}: ${reason}`);
-	process.exit(1);
+	return paths;
 }
+runMain(main);
 //#endregion
 export {};