pi-gsd 2.0.1 → 2.0.2

package/src/lib/roadmap.ts

@@ -1,378 +0,0 @@
-/**
- * roadmap.ts - Roadmap parsing and update operations.
- */
-
-import fs from "fs";
-import path from "path";
-import {
-	comparePhaseNum,
-	escapeRegex,
-	extractCurrentMilestone,
-	findPhaseInternal,
-	gsdError,
-	loadConfig,
-	normalizePhaseName,
-	output,
-	planningPaths,
-	replaceInCurrentMilestone,
-	stripShippedMilestones,
-} from "./core.js";
-import { extractFrontmatter } from "./frontmatter.js";
-
-export function cmdRoadmapGetPhase(
-	cwd: string,
-	phaseNum: string | undefined,
-	raw: boolean,
-): void {
-	const roadmapPath = planningPaths(cwd).roadmap;
-	if (!fs.existsSync(roadmapPath)) {
-		output({ found: false, error: "ROADMAP.md not found" }, raw, "");
-		return;
-	}
-	try {
-		const content = extractCurrentMilestone(
-			fs.readFileSync(roadmapPath, "utf-8"),
-			cwd,
-		);
-		const escapedPhase = escapeRegex(phaseNum ?? "");
-		const phasePattern = new RegExp(
-			`#{2,4}\\s*Phase\\s+${escapedPhase}:\\s*([^\\n]+)`,
-			"i",
-		);
-		const headerMatch = content.match(phasePattern);
-		if (!headerMatch) {
-			const checklistPattern = new RegExp(
-				`-\\s*\\[[ x]\\]\\s*\\*\\*Phase\\s+${escapedPhase}:\\s*([^*]+)\\*\\*`,
-				"i",
-			);
-			const checklistMatch = content.match(checklistPattern);
-			if (checklistMatch) {
-				output(
-					{
-						found: false,
-						phase_number: phaseNum,
-						phase_name: checklistMatch[1].trim(),
-						error: "malformed_roadmap",
-						message: `Phase ${phaseNum} exists in summary list but missing detail section.`,
-					},
-					raw,
-					"",
-				);
-				return;
-			}
-			output({ found: false, phase_number: phaseNum }, raw, "");
-			return;
-		}
-		const phaseName = headerMatch[1].trim();
-		const headerIndex = headerMatch.index!;
-		const restOfContent = content.slice(headerIndex);
-		const nextHeaderMatch = restOfContent.match(/\n#{2,4}\s+Phase\s+\d/i);
-		const sectionEnd = nextHeaderMatch
-			? headerIndex + nextHeaderMatch.index!
-			: content.length;
-		const section = content.slice(headerIndex, sectionEnd).trim();
-		const goalMatch = section.match(/\*\*Goal(?::\*\*|\*\*:)\s*([^\n]+)/i);
-		const criteriaMatch = section.match(
-			/\*\*Success Criteria\*\*[^\n]*:\s*\n((?:\s*\d+\.\s*[^\n]+\n?)+)/i,
-		);
-		const success_criteria = criteriaMatch
-			? criteriaMatch[1]
-					.trim()
-					.split("\n")
-					.map((l) => l.replace(/^\s*\d+\.\s*/, "").trim())
-					.filter(Boolean)
-			: [];
-		output(
-			{
-				found: true,
-				phase_number: phaseNum,
-				phase_name: phaseName,
-				goal: goalMatch ? goalMatch[1].trim() : null,
-				success_criteria,
-				section,
-			},
-			raw,
-			section,
-		);
-	} catch (e) {
-		gsdError("Failed to read ROADMAP.md: " + (e as Error).message);
-	}
-}
-
-interface RoadmapPhaseItem {
-	number: string;
-	name: string;
-	goal: string | null;
-	depends_on: string | null;
-	plan_count: number;
-	summary_count: number;
-	has_context: boolean;
-	has_research: boolean;
-	disk_status: string;
-	roadmap_complete: boolean;
-}
-
-export function cmdRoadmapAnalyze(cwd: string, raw: boolean): void {
-	const roadmapPath = planningPaths(cwd).roadmap;
-	if (!fs.existsSync(roadmapPath)) {
-		output(
-			{
-				error: "ROADMAP.md not found",
-				milestones: [],
-				phases: [],
-				current_phase: null,
-			},
-			raw,
-		);
-		return;
-	}
-	const rawContent = fs.readFileSync(roadmapPath, "utf-8");
-	const content = extractCurrentMilestone(rawContent, cwd);
-	const phasesDir = planningPaths(cwd).phases;
-
-	const phasePattern =
-		/#{2,4}\s*Phase\s+(\d+[A-Z]?(?:\.\d+)*)\s*:\s*([^\n]+)/gi;
-	const phases: RoadmapPhaseItem[] = [];
-	let match: RegExpExecArray | null;
-
-	while ((match = phasePattern.exec(content)) !== null) {
-		const phaseNum = match[1],
-			phaseName = match[2].replace(/\(INSERTED\)/i, "").trim();
-		const sectionStart = match.index;
-		const nextHeader = content
-			.slice(sectionStart)
-			.match(/\n#{2,4}\s+Phase\s+\d/i);
-		const sectionEnd = nextHeader
-			? sectionStart + nextHeader.index!
-			: content.length;
-		const section = content.slice(sectionStart, sectionEnd);
-		const goalMatch = section.match(/\*\*Goal(?::\*\*|\*\*:)\s*([^\n]+)/i);
-		const dependsMatch = section.match(
-			/\*\*Depends on(?::\*\*|\*\*:)\s*([^\n]+)/i,
-		);
-		const normalized = normalizePhaseName(phaseNum);
-		let diskStatus = "no_directory",
-			planCount = 0,
-			summaryCount = 0,
-			hasContext = false,
-			hasResearch = false;
-		try {
-			const dirs = fs
-				.readdirSync(phasesDir, { withFileTypes: true })
-				.filter((e) => e.isDirectory())
-				.map((e) => e.name);
-			const dirMatch = dirs.find(
-				(d) => d.startsWith(normalized + "-") || d === normalized,
-			);
-			if (dirMatch) {
-				const phaseFiles = fs.readdirSync(path.join(phasesDir, dirMatch));
-				planCount = phaseFiles.filter(
-					(f) => f.endsWith("-PLAN.md") || f === "PLAN.md",
-				).length;
-				summaryCount = phaseFiles.filter(
-					(f) => f.endsWith("-SUMMARY.md") || f === "SUMMARY.md",
-				).length;
-				hasContext = phaseFiles.some(
-					(f) => f.endsWith("-CONTEXT.md") || f === "CONTEXT.md",
-				);
-				hasResearch = phaseFiles.some(
-					(f) => f.endsWith("-RESEARCH.md") || f === "RESEARCH.md",
-				);
-				if (summaryCount >= planCount && planCount > 0) diskStatus = "complete";
-				else if (summaryCount > 0) diskStatus = "partial";
-				else if (planCount > 0) diskStatus = "planned";
-				else if (hasResearch) diskStatus = "researched";
-				else if (hasContext) diskStatus = "discussed";
-				else diskStatus = "empty";
-			}
-		} catch {
-			/* ok */
-		}
-		const checkboxPattern = new RegExp(
-			`-\\s*\\[(x| )\\]\\s*.*Phase\\s+${escapeRegex(phaseNum)}[:\\s]`,
-			"i",
-		);
-		const checkboxMatch = content.match(checkboxPattern);
-		const roadmapComplete = checkboxMatch ? checkboxMatch[1] === "x" : false;
-		if (roadmapComplete && diskStatus !== "complete") diskStatus = "complete";
-		phases.push({
-			number: phaseNum,
-			name: phaseName,
-			goal: goalMatch ? goalMatch[1].trim() : null,
-			depends_on: dependsMatch ? dependsMatch[1].trim() : null,
-			plan_count: planCount,
-			summary_count: summaryCount,
-			has_context: hasContext,
-			has_research: hasResearch,
-			disk_status: diskStatus,
-			roadmap_complete: roadmapComplete,
-		});
-	}
-
-	const milestones: Array<{ heading: string; version: string }> = [];
-	const milestonePattern = /##\s*(.*v(\d+(?:\.\d+)+)[^(\n]*)/gi;
-	let mMatch: RegExpExecArray | null;
-	while ((mMatch = milestonePattern.exec(content)) !== null)
-		milestones.push({ heading: mMatch[1].trim(), version: "v" + mMatch[2] });
-
-	const currentPhase =
-		phases.find(
-			(p) => p.disk_status === "planned" || p.disk_status === "partial",
-		) ?? null;
-	const nextPhase =
-		phases.find((p) =>
-			["empty", "no_directory", "discussed", "researched"].includes(
-				p.disk_status,
-			),
-		) ?? null;
-	const totalPlans = phases.reduce(
-		(s: number, p: { plan_count: number }) => s + p.plan_count,
-		0,
-	);
-	const totalSummaries = phases.reduce(
-		(s: number, p: { summary_count: number }) => s + p.summary_count,
-		0,
-	);
-	const completedPhases = phases.filter(
-		(p: { disk_status: string }) => p.disk_status === "complete",
-	).length;
-
-	const checklistPattern = /-\s*\[[ x]\]\s*\*\*Phase\s+(\d+[A-Z]?(?:\.\d+)*)/gi;
-	const checklistPhases = new Set<string>();
-	let clm: RegExpExecArray | null;
-	while ((clm = checklistPattern.exec(content)) !== null)
-		checklistPhases.add(clm[1]);
-	const detailPhases = new Set(phases.map((p: { number: string }) => p.number));
-	const missingDetails = [...checklistPhases].filter(
-		(p) => !detailPhases.has(p),
-	);
-
-	output(
-		{
-			milestones,
-			phases,
-			phase_count: phases.length,
-			completed_phases: completedPhases,
-			total_plans: totalPlans,
-			total_summaries: totalSummaries,
-			progress_percent:
-				totalPlans > 0
-					? Math.min(100, Math.round((totalSummaries / totalPlans) * 100))
-					: 0,
-			current_phase: currentPhase ? currentPhase.number : null,
-			next_phase: nextPhase ? nextPhase.number : null,
-			missing_phase_details: missingDetails.length > 0 ? missingDetails : null,
-		},
-		raw,
-	);
-}
-
-export function cmdRoadmapUpdatePlanProgress(
-	cwd: string,
-	phaseNum: string | undefined,
-	raw: boolean,
-): void {
-	if (!phaseNum)
-		gsdError("phase number required for roadmap update-plan-progress");
-	const roadmapPath = planningPaths(cwd).roadmap;
-	const phaseInfo = findPhaseInternal(cwd, phaseNum!);
-	if (!phaseInfo) gsdError(`Phase ${phaseNum} not found`);
-	const planCount = phaseInfo!.plans.length,
-		summaryCount = phaseInfo!.summaries.length;
-	if (planCount === 0) {
-		output(
-			{
-				updated: false,
-				reason: "No plans found",
-				plan_count: 0,
-				summary_count: 0,
-			},
-			raw,
-			"no plans",
-		);
-		return;
-	}
-	const isComplete = summaryCount >= planCount;
-	const status = isComplete
-		? "Complete"
-		: summaryCount > 0
-			? "In Progress"
-			: "Planned";
-	const today = new Date().toISOString().split("T")[0];
-	if (!fs.existsSync(roadmapPath)) {
-		output(
-			{
-				updated: false,
-				reason: "ROADMAP.md not found",
-				plan_count: planCount,
-				summary_count: summaryCount,
-			},
-			raw,
-			"no roadmap",
-		);
-		return;
-	}
-	let roadmapContent = fs.readFileSync(roadmapPath, "utf-8");
-	const phaseEscaped = escapeRegex(phaseNum!);
-	const tableRowPattern = new RegExp(
-		`^(\\|\\s*${phaseEscaped}\\.?\\s[^|]*(?:\\|[^\\n]*))$`,
-		"im",
-	);
-	const dateField = isComplete ? ` ${today} ` : "  ";
-	roadmapContent = roadmapContent.replace(tableRowPattern, (fullRow) => {
-		const cells = fullRow.split("|").slice(1, -1);
-		if (cells.length === 5) {
-			cells[2] = ` ${summaryCount}/${planCount} `;
-			cells[3] = ` ${status.padEnd(11)}`;
-			cells[4] = dateField;
-		} else if (cells.length === 4) {
-			cells[1] = ` ${summaryCount}/${planCount} `;
-			cells[2] = ` ${status.padEnd(11)}`;
-			cells[3] = dateField;
-		}
-		return "|" + cells.join("|") + "|";
-	});
-	const planCountPattern = new RegExp(
-		`(#{2,4}\\s*Phase\\s+${phaseEscaped}[\\s\\S]*?\\*\\*Plans:\\*\\*\\s*)[^\\n]+`,
-		"i",
-	);
-	roadmapContent = replaceInCurrentMilestone(
-		roadmapContent,
-		planCountPattern,
-		`$1${isComplete ? `${summaryCount}/${planCount} plans complete` : `${summaryCount}/${planCount} plans executed`}`,
-	);
-	if (isComplete) {
-		const checkboxPattern = new RegExp(
-			`(-\\s*\\[)[ ](\\]\\s*.*Phase\\s+${phaseEscaped}[:\\s][^\\n]*)`,
-			"i",
-		);
-		roadmapContent = replaceInCurrentMilestone(
-			roadmapContent,
-			checkboxPattern,
-			`$1x$2 (completed ${today})`,
-		);
-	}
-	for (const summaryFile of phaseInfo!.summaries) {
-		const planId = summaryFile
-			.replace("-SUMMARY.md", "")
-			.replace("SUMMARY.md", "");
-		if (!planId) continue;
-		roadmapContent = roadmapContent.replace(
-			new RegExp(`(-\\s*\\[) (\\]\\s*${escapeRegex(planId)})`, "i"),
-			"$1x$2",
-		);
-	}
-	fs.writeFileSync(roadmapPath, roadmapContent, "utf-8");
-	output(
-		{
-			updated: true,
-			phase: phaseNum,
-			plan_count: planCount,
-			summary_count: summaryCount,
-			status,
-			complete: isComplete,
-		},
-		raw,
-		`${summaryCount}/${planCount} ${status}`,
-	);
-}

package/src/lib/schemas.ts

@@ -1,290 +0,0 @@
-/**
- * schemas.ts - Zod schemas for all .planning/ file structures.
- *
- * Covers: STATE.md frontmatter, ROADMAP.md phase entries, PLAN.md frontmatter,
- *         UAT.md checkpoint structure, and .planning/config.json.
- *
- * All schemas are permissive (use .passthrough()) to accept 100% of valid
- * GSD v1.30.0 .planning/ files without error, even if they carry extra fields.
- *
- * TypeScript types are exported via z.infer<>.
- */
-
-import { z } from "zod";
-
-// ─── STATE.md Frontmatter ─────────────────────────────────────────────────────
-
-/**
- * Schema for STATE.md frontmatter key-value fields.
- *
- * STATE.md uses a bespoke "key: value" format (not strict YAML), parsed via
- * stateExtractField(). All fields are optional strings - the file may contain
- * only a subset depending on project state.
- */
-export const StateFrontmatterSchema = z
-	.object({
-		/** Active milestone version (e.g. "1.0.0") */
-		milestone: z.string().optional(),
-		/** Human-readable milestone name */
-		milestone_name: z.string().optional(),
-		/** Current phase number (e.g. "3", "3.1") */
-		current_phase: z.string().optional(),
-		/** Descriptive name of the current phase */
-		current_phase_name: z.string().optional(),
-		/** Current plan filename (e.g. "001-PLAN.md") */
-		current_plan: z.string().optional(),
-		/** Total number of phases in the milestone */
-		total_phases: z.coerce.number().int().nonnegative().optional(),
-		/** Total number of plans within the current phase */
-		total_plans_in_phase: z.coerce.number().int().nonnegative().optional(),
-		/**
-		 * Workflow status - free-text field.
-		 * Common values: "In Progress", "Paused", "Stopped", "Complete".
-		 */
-		status: z.string().optional(),
-		/** Percentage completion (e.g. "42%") */
-		progress: z.string().optional(),
-		/** ISO-8601 timestamp or human-readable last-activity string */
-		last_activity: z.string().optional(),
-		/** ISO-8601 or human-readable timestamp when work was paused */
-		paused_at: z.string().optional(),
-		/** ISO-8601 or human-readable timestamp when work was stopped */
-		stopped_at: z.string().optional(),
-	})
-	.passthrough();
-
-export type StateFrontmatter = z.infer<typeof StateFrontmatterSchema>;
-
-// ─── ROADMAP.md Phase Entry ───────────────────────────────────────────────────
-
-/**
- * Schema for a single parsed phase entry from ROADMAP.md.
- *
- * This represents the structured data returned by cmdRoadmapGetPhase() rather
- * than raw markdown - the roadmap file itself is free-form markdown.
- */
-export const RoadmapPhaseEntrySchema = z
-	.object({
-		/** Indicates a successful lookup */
-		found: z.literal(true),
-		/** Phase identifier, e.g. "3", "3.1", "10B" */
-		phase_number: z.string(),
-		/** Human-readable phase title */
-		phase_name: z.string(),
-		/** One-line goal statement extracted from **Goal:** line (null if absent) */
-		goal: z.string().nullable(),
-		/** Ordered success criteria items */
-		success_criteria: z.array(z.string()).default([]),
-		/** Raw markdown section text (for debugging/display) */
-		section: z.string().optional(),
-	})
-	.passthrough();
-
-export type RoadmapPhaseEntry = z.infer<typeof RoadmapPhaseEntrySchema>;
-
-// ─── PLAN.md Frontmatter ──────────────────────────────────────────────────────
-
-/**
- * Schema for PLAN.md YAML frontmatter (written by /gsd-plan-phase).
- *
- * GSD v1.30.0 requires these 8 fields. Additional fields may be present
- * (handled by .passthrough()).
- */
-export const PlanFrontmatterSchema = z
-	.object({
-		/** Phase number this plan belongs to */
-		phase: z.union([z.string(), z.number()]),
-		/** Plan slug / short identifier (e.g. "001") */
-		plan: z.union([z.string(), z.number()]),
-		/**
-		 * Plan type.
-		 * Common values: "implementation", "research", "verification", "ui".
-		 */
-		type: z.string(),
-		/**
-		 * Execution wave for parallelization (e.g. 1, 2, "1").
-		 * Wave 1 plans may run in parallel; later waves depend on earlier ones.
-		 */
-		wave: z.union([z.string(), z.number()]),
-		/**
-		 * Dependency list - plan slugs that must complete before this plan runs.
-		 * Can be an empty string, a comma-separated list, or an array.
-		 */
-		depends_on: z.union([z.string(), z.array(z.string())]),
-		/**
-		 * Files this plan intends to create or modify.
-		 * Can be an empty string, comma-separated list, or array.
-		 */
-		files_modified: z.union([z.string(), z.array(z.string())]),
-		/** Whether this plan can run without human intervention */
-		autonomous: z.union([z.boolean(), z.string()]),
-		/**
-		 * Must-have deliverables / acceptance items.
-		 * Can be an empty string, a comma-separated list, or an array.
-		 */
-		must_haves: z.union([z.string(), z.array(z.string())]),
-	})
-	.passthrough();
-
-export type PlanFrontmatter = z.infer<typeof PlanFrontmatterSchema>;
-
-/**
- * Schema for SUMMARY.md frontmatter (produced after phase execution).
- */
-export const SummaryFrontmatterSchema = z
-	.object({
-		/** Phase number (string or numeric) */
-		phase: z.union([z.string(), z.number()]),
-		/** Plan slug */
-		plan: z.union([z.string(), z.number()]),
-		/** Subsystem or area this plan affected */
-		subsystem: z.string(),
-		/** Comma-separated tags or array */
-		tags: z.union([z.string(), z.array(z.string())]),
-		/** Human-readable duration string (e.g. "45m", "2h") */
-		duration: z.string(),
-		/** ISO-8601 completion timestamp or human-readable date */
-		completed: z.string(),
-	})
-	.passthrough();
-
-export type SummaryFrontmatter = z.infer<typeof SummaryFrontmatterSchema>;
-
-/**
- * Schema for VERIFICATION.md frontmatter.
- */
-export const VerificationFrontmatterSchema = z
-	.object({
-		/** Phase number */
-		phase: z.union([z.string(), z.number()]),
-		/** Whether verification passed */
-		verified: z.union([z.boolean(), z.string()]),
-		/** Verification status label (e.g. "pass", "fail", "partial") */
-		status: z.string(),
-		/** Numeric score (0–100) */
-		score: z.union([z.number(), z.string()]),
-	})
-	.passthrough();
-
-export type VerificationFrontmatter = z.infer<
-	typeof VerificationFrontmatterSchema
->;
-
-// ─── UAT.md Checkpoint Structure ─────────────────────────────────────────────
-
-/**
- * Schema for a single UAT checkpoint item parsed from a -UAT.md file.
- *
- * Matches the UatItem interface used by cmdAuditUat().
- */
-export const UatCheckpointSchema = z
-	.object({
-		/** Optional numeric test index (1-based) */
-		test: z.number().int().positive().optional(),
-		/** Human-readable test name */
-		name: z.string(),
-		/** Expected outcome description */
-		expected: z.string().optional(),
-		/** Actual result ("pass", "fail", "blocked", "pending", etc.) */
-		result: z.string(),
-		/** Grouping category for this test */
-		category: z.string(),
-		/** Optional reason if test failed or is blocked */
-		reason: z.string().optional(),
-		/** Optional reference to blocking issue/phase */
-		blocked_by: z.string().optional(),
-	})
-	.passthrough();
-
-export type UatCheckpoint = z.infer<typeof UatCheckpointSchema>;
-
-/**
- * Schema for the full structured UAT audit result (as returned by pi-gsd-tools).
- */
-export const UatAuditResultSchema = z
-	.object({
-		phase: z.string(),
-		phase_dir: z.string(),
-		file: z.string(),
-		file_path: z.string(),
-		type: z.literal("uat"),
-		status: z.string(),
-		items: z.array(UatCheckpointSchema),
-	})
-	.passthrough();
-
-export type UatAuditResult = z.infer<typeof UatAuditResultSchema>;
-
-// ─── .planning/config.json ────────────────────────────────────────────────────
-
-const GitConfigSchema = z
-	.object({
-		branching_strategy: z
-			.enum(["none", "phase", "milestone", "workstream"])
-			.default("none"),
-		phase_branch_template: z.string().default("gsd/phase-{phase}-{slug}"),
-		milestone_branch_template: z.string().default("gsd/{milestone}-{slug}"),
-		quick_branch_template: z.string().nullable().default(null),
-	})
-	.passthrough();
-
-const WorkflowConfigSchema = z
-	.object({
-		research: z.boolean().default(true),
-		plan_check: z.boolean().default(true),
-		verifier: z.boolean().default(true),
-		nyquist_validation: z.boolean().default(true),
-		auto_advance: z.boolean().default(false),
-		node_repair: z.boolean().default(true),
-		node_repair_budget: z.number().int().nonnegative().default(2),
-		auto_retry_audit: z.boolean().default(true),
-		auto_retry_audit_budget: z.number().int().nonnegative().default(1),
-		auto_retry_tech_debt: z.boolean().default(true),
-		auto_retry_tech_debt_budget: z.number().int().nonnegative().default(1),
-		ui_phase: z.boolean().default(true),
-		ui_safety_gate: z.boolean().default(true),
-		text_mode: z.boolean().default(false),
-		research_before_questions: z.boolean().default(false),
-		discuss_mode: z.string().default("discuss"),
-		skip_discuss: z.boolean().default(false),
-		_auto_chain_active: z.boolean().default(false),
-	})
-	.passthrough();
-
-const HooksConfigSchema = z
-	.object({
-		context_warnings: z.boolean().default(true),
-		workflow_guard: z.boolean().default(false),
-	})
-	.passthrough();
-
-/**
- * Schema for .planning/config.json.
- *
- * Generated by /gsd-new-project (cmdConfigNewProject) and persisted for the
- * lifetime of the project. The outer object uses .passthrough() so that
- * user-added agent_skills entries and future GSD keys are accepted.
- */
-export const PlanningConfigSchema = z
-	.object({
-		model_profile: z
-			.enum(["quality", "balanced", "budget", "inherit"])
-			.default("balanced"),
-		commit_docs: z.boolean().default(true),
-		parallelization: z.boolean().default(true),
-		search_gitignored: z.boolean().default(false),
-		brave_search: z.boolean().default(false),
-		firecrawl: z.boolean().default(false),
-		exa_search: z.boolean().default(false),
-		git: GitConfigSchema.default({}),
-		workflow: WorkflowConfigSchema.default({}),
-		hooks: HooksConfigSchema.default({}),
-		/** Map of agent-type → enabled flag or config object */
-		agent_skills: z.record(z.string(), z.unknown()).default({}),
-	})
-	.passthrough();
-
-export type PlanningConfig = z.infer<typeof PlanningConfigSchema>;
-export type GitConfig = z.infer<typeof GitConfigSchema>;
-export type WorkflowConfig = z.infer<typeof WorkflowConfigSchema>;
-export type HooksConfig = z.infer<typeof HooksConfigSchema>;