guardian-framework 0.1.77 → 0.1.79

package/dist/cli.js

@@ -3197,7 +3197,7 @@ __export(exports_package, {
   bin: () => bin,
   author: () => author
 });
-var name = "guardian-framework", version = "0.1.77", description = "Token-optimized agentic framework scaffolder with pi-first architecture", type = "module", main = "dist/exports.js", exports, types = "dist/exports.d.ts", bin, files, engines, scripts, publishConfig, pi, repository, homepage = "https://github.com/arman-jalili/guardian-framework#readme", bugs, dependencies, devDependencies, keywords, author = "Arman Wolkensteiner-Jalili", license = "MIT", package_default;
+var name = "guardian-framework", version = "0.1.79", description = "Token-optimized agentic framework scaffolder with pi-first architecture", type = "module", main = "dist/exports.js", exports, types = "dist/exports.d.ts", bin, files, engines, scripts, publishConfig, pi, repository, homepage = "https://github.com/arman-jalili/guardian-framework#readme", bugs, dependencies, devDependencies, keywords, author = "Arman Wolkensteiner-Jalili", license = "MIT", package_default;
 var init_package = __esm(() => {
   exports = {
     ".": {

package/dist/exports.js

@@ -1982,7 +1982,7 @@ __export(exports_package, {
   bin: () => bin,
   author: () => author
 });
-var name = "guardian-framework", version = "0.1.77", description = "Token-optimized agentic framework scaffolder with pi-first architecture", type = "module", main = "dist/exports.js", exports, types = "dist/exports.d.ts", bin, files, engines, scripts, publishConfig, pi, repository, homepage = "https://github.com/arman-jalili/guardian-framework#readme", bugs, dependencies, devDependencies, keywords, author = "Arman Wolkensteiner-Jalili", license = "MIT", package_default;
+var name = "guardian-framework", version = "0.1.79", description = "Token-optimized agentic framework scaffolder with pi-first architecture", type = "module", main = "dist/exports.js", exports, types = "dist/exports.d.ts", bin, files, engines, scripts, publishConfig, pi, repository, homepage = "https://github.com/arman-jalili/guardian-framework#readme", bugs, dependencies, devDependencies, keywords, author = "Arman Wolkensteiner-Jalili", license = "MIT", package_default;
 var init_package = __esm(() => {
   exports = {
     ".": {

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "guardian-framework",
-	"version": "0.1.77",
+	"version": "0.1.79",
 	"description": "Token-optimized agentic framework scaffolder with pi-first architecture",
 	"type": "module",
 	"main": "dist/exports.js",

package/templates/pi/architecture/modules/module-template.md

@@ -121,6 +121,18 @@ Response → commit or rollback → UI update
 
 ---
 
+## Acceptance Criteria
+
+Each component in this module has specific acceptance criteria that must be verified
+before the implementation issue can be closed. These ACs flow into the generated issues.
+
+| # | Component | Criterion | Verify In |
+|---|-----------|-----------|-----------|
+| 1 | [ComponentName] | [Specific, testable criterion for this component] | [unit test / integration test / manual] |
+| 2 | [ComponentName] | [Another criterion] | [verification method] |
+
+---
+
 ## Dependencies
 
 ### Depends On

package/templates/pi/extensions/architect-lib/forge-adapter.ts

@@ -141,7 +141,8 @@ export function getGitBaseUrl(repoTool: string): string {
 
 export function commandExists(cmd: string): boolean {
 	try {
-		execSync(`command -v ${cmd}`, { stdio: "ignore" });
+		// Pass cmd as bash argument ($1) to avoid shell interpolation issues
+		execFileSync("bash", ["-c", `command -v "$1"`, "_", cmd], { stdio: "ignore" });
 		return true;
 	} catch {
 		return false;
@@ -150,10 +151,15 @@ export function commandExists(cmd: string): boolean {
 
 /**
  * Run a bash script and return exit code + stdout.
+ *
+ * Uses execFileSync with explicit arguments to avoid shell metacharacter bugs.
+ * The script is passed directly to bash -c without an outer shell layer,
+ * so characters like &, $, ", and ` inside the script are handled by bash,
+ * not by an intermediate sh process.
  */
 export function runScript(cwd: string, script: string): { exitCode: number; stdout: string } {
 	try {
-		const stdout = execSync(`bash -c "${script}"`, { cwd, timeout: 120_000, encoding: "utf-8" });
+		const stdout = execFileSync("bash", ["-c", script], { cwd, timeout: 120_000, encoding: "utf-8" });
 		return { exitCode: 0, stdout };
 	} catch (e: unknown) {
 		const err = e as { status?: number; stdout?: string; message?: string };

package/templates/pi/extensions/architect-lib/generators.ts

@@ -1,64 +1,245 @@
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
 import type { ArchitectureSlice, ModuleComponent } from "./types.ts";
 
+// ── Module Doc Readers ───────────────────────────────────────────────────────
+
+/** Read the raw module architecture doc, or empty string if missing. */
+function readModuleDoc(cwd: string, moduleId: string): string {
+	try {
+		return readFileSync(
+			join(cwd, ".pi", "architecture", "modules", `${moduleId}.md`),
+			"utf-8",
+		);
+	} catch {
+		return "";
+	}
+}
+
+/** Extract a named section's body (between ## heading and next ## / --- / EOF). */
+function extractSection(doc: string, heading: string): string {
+	const re = new RegExp(`## ${heading}\n([\\s\\S]*?)(?=\n##|\n---|$)`);
+	const m = re.exec(doc);
+	return m ? m[1].trim() : "";
+}
+
+interface AcRow { num: string; component?: string; criterion: string; verifyIn: string; }
+
+/**
+ * Parse every AC row from ## Acceptance Criteria.
+ * Supports:
+ *   4-column: `| # | Component | Criterion | Verify In |`
+ *   3-column: `| # | Criterion | Verify In |`
+ * Returns rows with component populated when the 4-col format is detected.
+ */
+function parseAcTable(doc: string): AcRow[] {
+	const section = extractSection(doc, "Acceptance Criteria");
+	if (!section) return [];
+	const rows = section.match(/^\| [\d✅☐][^|]*\|[^|]+\|[^|]+\|[^|]*\|$/gm) ?? [];
+	return rows.map((row) => {
+		const parts = row.split("|").map((p) => p.trim()).filter(Boolean);
+		// 4-col: [num, component, criterion, verifyIn]
+		// 3-col: [num, criterion, verifyIn]
+		const isFourCol = parts.length >= 4 && parts[1] !== "Criterion";
+		if (isFourCol) {
+			return { num: parts[0] ?? "", component: parts[1], criterion: parts[2] ?? "", verifyIn: parts[3] ?? "" };
+		}
+		return { num: parts[0] ?? "", criterion: parts[1] ?? "", verifyIn: parts[2] ?? "" };
+	});
+}
+
+/** Parse numbered steps from ## Implementation Sequence. */
+function parseImplSequence(doc: string): string[] {
+	const section = extractSection(doc, "Implementation Sequence");
+	if (!section) return [];
+	return (section.match(/^\d+\. .+$/gm) ?? []).map((s) => s.trim());
+}
+
+/**
+ * Filter ACs that belong to a specific component.
+ * 
+ * When the AC table has a Component column (4-col format), ACs are matched
+ * by component name. Falls back to keyword matching on criterion text when
+ * no component column is present.
+ */
+function primaryAcs(acs: AcRow[], componentName: string): AcRow[] {
+	if (acs.length === 0) return [];
+
+	// Prefer explicit component column match
+	const byComponent = acs.filter((ac) => ac.component && ac.component === componentName);
+	if (byComponent.length > 0) return byComponent;
+
+	// Fallback: keyword match on criterion text
+	const lower = componentName.toLowerCase();
+	const isDomainModel =
+		(lower.includes("entity") || lower.includes("aggregate") ||
+		 lower.includes("snapshot") || lower.includes("enum")) &&
+		!lower.includes("repository");
+
+	const matched = acs.filter((ac) =>
+		ac.criterion.toLowerCase().includes(lower.replace(/[^a-z0-9]/g, "")),
+	);
+	if (matched.length > 0) return matched;
+
+	if (isDomainModel) {
+		const domainKeywords = ["entity", "aggregate", "enum", "value object", "jpa", "migration", "flyway", "snapshot", "status"];
+		const filtered = acs.filter((ac) =>
+			domainKeywords.some((kw) => ac.criterion.toLowerCase().includes(kw)),
+		);
+		if (filtered.length > 0) return filtered;
+	}
+
+	// Last resort: evenly split ACs among all components (assuming n components, take 1/n-th)
+	return acs.slice(0, Math.max(1, Math.ceil(acs.length / 4)));
+}
+
+/** Format AcRow[] as a markdown table body (no header). Includes Component column if any row has one. */
+function acRowsToMarkdown(rows: AcRow[]): string {
+	const hasComponent = rows.some((r) => r.component);
+	if (hasComponent) {
+		return rows.map((r) => `| ${r.num} | ${r.component} | ${r.criterion} | ${r.verifyIn} |`).join("\n");
+	}
+	return rows.map((r) => `| ${r.num} | ${r.criterion} | ${r.verifyIn} |`).join("\n");
+}
+
+/** Build a human-readable title for the component issue. */
+function buildIssueTitle(comp: ModuleComponent, moduleId: string): string {
+	return `Implement ${comp.name} — ${moduleId}`;
+}
+
+/** Derive `in_scope` lines from primary ACs. Falls back to generic if none. */
+function buildInScope(comp: ModuleComponent, primaryAcRows: AcRow[], implSteps: string[], moduleId: string): string[] {
+	if (primaryAcRows.length > 0) {
+		return primaryAcRows.slice(0, 6).map((r) => r.criterion.replace(/^✅\s*/, ""));
+	}
+	if (implSteps.length > 0) {
+		return implSteps.slice(0, 4).map((s) => s.replace(/^\d+\.\s*/, ""));
+	}
+	return [
+		`Implement ${comp.name} for the ${moduleId} module`,
+		"Write unit tests for all public methods",
+		"Add integration tests with upstream/downstream components",
+	];
+}
+
+/** Detect whether project at `cwd` is a Java project. */
+function isJavaProject(cwd?: string): boolean {
+	if (!cwd) return false;
+	try {
+		return existsSync(join(cwd, "pom.xml")) ||
+		       existsSync(join(cwd, "build.gradle")) ||
+		       existsSync(join(cwd, "build.gradle.kts"));
+	} catch {
+		return false;
+	}
+}
+
 // ── Issue Generation ──
 
 export function generateIssueMarkdown(
-	component: ModuleComponent,
+	comp: ModuleComponent,
 	slice: ArchitectureSlice,
 	issueIndex: number,
-	totalIssues: number,
+	_totalIssues: number,
 	tdd?: boolean,
+	cwd?: string,
 ): string {
 	const moduleId = slice.module.replace(/^module-/, "");
-	const componentName = component.name.toLowerCase().replace(/\s+/g, "-");
 	const issueId = `ISSUE-${moduleId.toUpperCase()}-${issueIndex + 1}`;
 
+	// ── Read module doc for specifics ──
+	const doc = cwd ? readModuleDoc(cwd, slice.module) : "";
+	const allAcs = parseAcTable(doc);
+	const implSteps = parseImplSequence(doc);
+	const compAcs = primaryAcs(allAcs, comp.name);
+
+	const title = buildIssueTitle(comp, moduleId);
+	const inScope = buildInScope(comp, compAcs, implSteps, moduleId);
+
+	// Language-aware test paths
+	const isJava = isJavaProject(cwd);
+	const testBaseDir = isJava ? "src/test/java" : "tests/unit";
+	const testRunnerHint = isJava ? "mvn test" : "bun test";
+
 	const testLine = tdd
-		? `    - "update: tests/unit/${moduleId}/${componentName}/ (failing tests already generated — make them pass)"`
-		: `    - "create: tests/unit/${moduleId}/${componentName}/"`;
+		? `    - "update: ${testBaseDir}/ (failing tests already generated — make them pass)"`
+		: `    - "create: ${testBaseDir}/"`;
+
+	// YAML front-matter ACs
+	const yamlAcs = compAcs.length > 0
+		? compAcs.map((r) => {
+			const c = r.criterion.replace(/^✅\s*/, "").replaceAll("\"", "'");
+			return `    - "${c}"`;
+		}).join("\n")
+		: `    - "CI pipeline passes (validate-ci.sh)"
+    - "All unit tests pass"
+    - "Architecture compliance (validate-architecture.sh)"
+    - "Canonical references valid (validate-canonical.sh)"`;
+
+	// Markdown body: all ACs
+	const hasCompCol = allAcs.some((a) => a.component);
+	const allAcHeader = hasCompCol
+		? `| # | Component | Criterion | Verify In |\n|---|-----------|-----------|-----------|`
+		: `| # | Criterion | Verify In |\n|---|-----------|-----------|`;
+	const allAcMarkdown = allAcs.length > 0
+		? `${allAcHeader}\n${acRowsToMarkdown(allAcs)}`
+		: `| # | Criterion | Validator |\n|---|-----------|-----------|\n| 1 | CI pipeline passes | \`validate-ci.sh\` |\n| 2 | All unit tests pass | \`validate-tests.sh\` |\n| 3 | Integration tests pass | \`validate-integration.sh\` |\n| 4 | Architecture compliance | \`validate-architecture.sh\` |\n| 5 | Canonical references valid | \`validate-canonical.sh\` |`;
+
+	// Implementation steps from module doc
+	const stepsMarkdown = implSteps.length > 0
+		? implSteps.map((s) => `- ${s}`).join("\n")
+		: `- Read .pi/architecture/modules/${slice.module}.md\n- Implement entities and interfaces\n- Implement infrastructure (adapter, mapper, repository)\n- Implement use case\n- Write unit + integration tests\n- Run validators\n- Create MR`;
+
+	const tddSteps = tdd
+		? [
+				"1. Read canonical architecture references",
+				`2. Run the pre-generated failing tests: \`cd ${testBaseDir} && ${testRunnerHint}\``,
+				"3. Verify tests FAIL (Red phase)",
+				"4. Implement domain entities and interfaces",
+				"5. Implement application service/handler",
+				"6. Add infrastructure connections",
+				"7. Run tests again — they should PASS (Green phase)",
+				"8. Refactor if needed (Refactor phase)",
+				"9. Write integration tests",
+				"10. Run all validators",
+				"11. Create MR",
+			].join("\n")
+		: [
+				"1. Read canonical architecture references",
+				"2. Create domain entities and interfaces",
+				"3. Implement application service/handler",
+				"4. Add infrastructure connections",
+				"5. Write unit tests (≥ 90% coverage)",
+				"6. Write integration tests",
+				"7. Run all validators",
+				"8. Create MR",
+			].join("\n");
 
 	return `---
 guardian_issue:
   id: "${issueId}"
   epic: "TBD"
-  component: "${component.name}"
+  component: "${comp.name}"
   module: "${slice.module}"
   status: planned
   priority: high
   dependencies:
-${component.dependencies.map((d) => `    - "${d}"`).join("\n")}
+${comp.dependencies.map((d) => `    - "${d}"`).join("\n")}
 
   in_scope:
-    - Implement ${component.name} for the ${slice.module} module
-    - Write unit tests for all public interfaces
-    - Add integration tests with upstream/downstream components
-    - Create API documentation
+${inScope.map((s) => { const sc = s.replaceAll("\"", "'"); return `    - "${sc}"`; }).join("\n")}
 
   out_of_scope:
-    - Changes to upstream components (${component.dependencies.join(", ")})
+    - Changes to upstream components (${comp.dependencies.join(", ") || "none"})
     - UI/frontend changes
     - Deployment pipeline configuration
 
-  affected_layers:
-    domain:
-      - New domain models for ${componentName}
-    application:
-      - New service/handler for ${componentName}
-    infrastructure:
-      - New database tables or external service connections
-    api:
-      - New endpoints or event handlers
-
   canonical_references:
-    - module: ".pi/architecture/modules/${slice.module}.md#${componentName}"
+    - module: ".pi/architecture/modules/${slice.module}.md"
+    - acceptance_criteria: ".pi/architecture/modules/${slice.module}.md#acceptance-criteria"
 
   acceptance_criteria:
-    - "CI pipeline passes (validate-ci.sh)"
-    - "All unit tests pass with ≥ 90% coverage"
-    - "Integration tests pass with upstream/downstream components"
-    - "validate-security.sh passes"
-    - "validate-architecture.sh passes"
-    - "validate-canonical.sh passes"
+${yamlAcs}
 
   validators:
     - ci
@@ -68,7 +249,9 @@ ${component.dependencies.map((d) => `    - "${d}"`).join("\n")}
     - canonical
 
   implementation_notes: |
-    ${component.description || "Implement this component according to the architecture module."}
+    Read .pi/architecture/modules/${slice.module}.md BEFORE implementing.
+    All Acceptance Criteria in that file must be satisfied before this issue is closed.
+    Component focus: ${comp.name}.
 
   file_changes:
     - "modify: src/${moduleId}/domain/"
@@ -76,85 +259,60 @@ ${component.dependencies.map((d) => `    - "${d}"`).join("\n")}
     - "modify: src/${moduleId}/infrastructure/"
     - "modify: src/${moduleId}/interfaces/"
     - ${testLine}
-    - "create: tests/integration/${moduleId}/${componentName}/"
 ---
 
-# ${issueId}: ${component.name}
+# ${issueId}: ${title}
 
 ## Intent
 
-${component.description || `Implement ${component.name} for the ${slice.module} module.`}
+Implement **${comp.name}** for the \`${slice.module}\` module.
+
+> ⚠️ **Read before implementing:** \`.pi/architecture/modules/${slice.module}.md\`
+> Every item in the **Acceptance Criteria** section of that file must be satisfied
+> before this issue is closed — including adapter, mapper, and WireMock items.
 
 ## Architecture Context
 
 - **Module:** ${slice.module}
-- **Component:** ${component.name}
-- **Status:** ${component.status}
-- **Dependencies:** ${component.dependencies.length > 0 ? component.dependencies.join(", ") : "none"}
-
-## Dependencies
-
-\`\`\`
-${component.dependencies.map((d) => `  └── ${d}`).join("\n") || "  └── (root component — no dependencies)"}
-\`\`\`
-
-## In Scope
-
-- Implement ${component.name} for the ${slice.module} module
-- Write unit tests for all public interfaces
-- Add integration tests with upstream/downstream components
-- Create API documentation
-
-## Out of Scope
+- **Component:** ${comp.name}
+- **Status:** ${comp.status}
+- **Dependencies:** ${comp.dependencies.length > 0 ? comp.dependencies.join(", ") : "none"}
 
-- Changes to upstream components
-- UI/frontend changes
-- Deployment pipeline configuration
+## In Scope (this component)
 
-## Affected Layers
+${inScope.map((s) => `- ${s}`).join("\n")}
 
-### Domain
-- New domain models for ${componentName}
+## Acceptance Criteria (this issue)
 
-### Application
-- New service/handler for ${componentName}
+These acceptance criteria must be satisfied before this issue can be closed:
 
-### Infrastructure
-- New database tables or external service connections
+| # | Criterion | Verify In |
+|---|-----------|-----------|
+${compAcs.length > 0 ? compAcs.map((r) => `| ${r.num} | ${r.criterion} | ${r.verifyIn} |`).join("\n") : `| 1 | CI pipeline passes | \`validate-ci.sh\` |\n| 2 | All unit tests pass | \`validate-tests.sh\` |\n| 3 | Architecture compliance | \`validate-architecture.sh\` |\n| 4 | Canonical references valid | \`validate-canonical.sh\` |`}
 
-### API
-- New endpoints or event handlers
+## Full Module Acceptance Criteria
 
-## Canonical References
+> All items below must pass before the **epic** is closed.
+> Items may be split across multiple issues — verify your component's items before creating the MR.
 
-- **Module:** \`.pi/architecture/modules/${slice.module}.md#${componentName}\`
+${allAcMarkdown}
 
-## Acceptance Criteria
+## Implementation Sequence (from module doc)
 
-| # | Criterion | Validator |
-|---|-----------|-----------|
-| 1 | CI pipeline passes | \`validate-ci.sh\` |
-| 2 | All unit tests pass with ≥ 90% coverage | \`validate-tests.sh\` |
-| 3 | Integration tests pass | \`validate-integration.sh\` |
-| 4 | Security checks pass | \`validate-security.sh\` |
-| 5 | Architecture compliance | \`validate-architecture.sh\` |
-| 6 | Canonical references valid | \`validate-canonical.sh\` |
+${stepsMarkdown}
 
 ## Implementation
 
-> **Agent:** This is your complete session context. All information you need is above.
-> Start by reading the canonical reference files, then implement following the layer structure.
+> **Agent instructions:**
+> 1. Open \`.pi/architecture/modules/${slice.module}.md\` — read the full Acceptance Criteria table
+> 2. Identify which rows are your responsibility for **${comp.name}**
+> 3. Implement all of them — entity, JPA entity, migration, adapter (all endpoints), mapper, use case
+> 4. Verify each AC row is satisfied in \`src/\` before marking done
+> 5. Run validators and create MR
 
 ### Steps
 
-1. Read canonical architecture references
-2. Create domain entities and interfaces
-3. Implement application service/handler
-4. Add infrastructure connections
-5. Write unit tests (≥ 90% coverage)
-6. Write integration tests
-7. Run all validators
-8. Create MR
+${tddSteps}
 `;
 }
 // ── Contract Freeze Generator ──
@@ -162,9 +320,13 @@ ${component.dependencies.map((d) => `  └── ${d}`).join("\n") || "  └─
 export function generateContractFreezeMarkdown(
 	slice: ArchitectureSlice,
 	epicName: string,
-	codegenSkill?: string,
+	_codegenSkill?: string,
+	cwd?: string,
 ): string {
 	const moduleId = slice.module.replace(/^module-/, "");
+	const doc = cwd ? readModuleDoc(cwd, slice.module) : "";
+	const implSteps = parseImplSequence(doc);
+	const allAcs = parseAcTable(doc);
 
 	return `---
 guardian_issue:
@@ -200,8 +362,8 @@ guardian_issue:
     - module: ".pi/architecture/modules/${slice.module}.md"
 
   acceptance_criteria:
-    - "All component interfaces defined as interfaces/types"
-    - "DTO schemas documented"
+    - "All component interfaces defined as stubs (TODO bodies)"
+    - "DTO schemas documented with field names and types"
     - "API contracts frozen and reviewed"
     - "Implementation PRs reference these contracts"
 
@@ -213,7 +375,7 @@ guardian_issue:
     Define the contract before any implementation. Every implementation issue
     depends on this contract being frozen first. The contract should include:
     interfaces, types, DTOs, event schemas, API paths, error formats.
-    ${codegenSkill ? `Follow: .pi/skills/agents/${codegenSkill}.md` : ""}
+    ${_codegenSkill ? `Follow: .pi/skills/agents/${_codegenSkill}.md` : ""}
 
   file_changes:
     - "create: src/${moduleId}/domain/"
@@ -256,11 +418,25 @@ ${slice.nextLogicalSlice.map((c: { name: string }) => `- ${c.name}`).join("\n")}
 
 | # | Criterion | How to Verify |
 |---|-----------|---------------|
-| 1 | All component interfaces defined | Check src/<group>/<module>/domain/ and application/ |
+| 1 | All component interfaces defined as stubs (TODO bodies) | Check src/<module>/domain/ and application/ |
 | 2 | Contracts reviewed and frozen | PR approval |
-| 3 | DTO schemas documented | OpenAPI / TypeSpec / equivalent |
+| 3 | DTO schemas documented with field names and types | OpenAPI / record types |
 | 4 | Implementation depends on contracts | No implementation without interface |
 
+${allAcs.length > 0
+	? (() => {
+		const hasComp = allAcs.some((a) => a.component);
+		const header = hasComp
+			? `| # | Component | Criterion | Verify In |\n|---|-----------|-----------|-----------|`
+			: `| # | Criterion | Verify In |\n|---|-----------|-----------|`;
+		return `## Full Module Acceptance Criteria (for reference)\n\n> These are the complete ACs for the module. The contract freeze must define the interfaces\n> so every row below can be implemented in subsequent issues.\n\n${header}\n${acRowsToMarkdown(allAcs)}`;
+	})()
+	: ""}
+
+${implSteps.length > 0
+	? `## Full Implementation Sequence (for reference)\n\n${implSteps.map((s) => '- ' + s).join("\n")}`
+	: ""}
+
 ## Implementation
 
 > **Agent:** Create interface-only files. No implementation. Use Clean Architecture layers:

package/templates/pi/extensions/architect-lib/tdd-generator.ts

@@ -48,7 +48,6 @@ export function generateEpicTestFiles(options: TddGenerateOptions): string[] {
 		moduleId,
 		cwd,
 		language,
-		testBaseDir = "tests/unit",
 		moduleName,
 	} = options;
 
@@ -56,11 +55,23 @@ export function generateEpicTestFiles(options: TddGenerateOptions): string[] {
 		return [];
 	}
 
+	// ── Language-specific base dir & path strategy ──
+	let testBaseDir = options.testBaseDir;
+	let modulePath: string;
+
+	if (language === "java") {
+		testBaseDir = testBaseDir ?? "src/test/java";
+		modulePath = (moduleName || moduleId).replace(/[^a-zA-Z0-9\/]/g, "-");
+	} else {
+		testBaseDir = testBaseDir ?? "tests/unit";
+		modulePath = moduleName || moduleId;
+	}
+
 	const generated: string[] = [];
-	const modulePath = moduleName || moduleId;
 
 	for (const comp of components) {
-		const componentId = comp.name.toLowerCase().replace(/[^a-z0-9]+/g, "-");
+		const componentId = comp.name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/(^-|-$)/g, "");
+
 		const testDir = join(cwd, testBaseDir, modulePath, componentId);
 		mkdirSync(testDir, { recursive: true });
 
@@ -125,7 +136,7 @@ function generateTestContent(
 function generateTypeScript(
 	component: ModuleComponent,
 	moduleId: string,
-	componentId: string,
+	_componentId: string,
 ): string {
 	const lines: string[] = [
 		`// Generated by Guardian TDD`,

package/templates/pi/extensions/architect-lib/types.ts

@@ -114,5 +114,6 @@ export type EpicState = {
 	currentIssueIndex: number;
 	createdAt: string;
 	tdd: boolean;
+	tddTestFiles: string[];
 };
 

package/templates/pi/extensions/architect.ts

@@ -6,7 +6,7 @@
 
 import { existsSync, mkdirSync, readFileSync, readdirSync, unlinkSync, writeFileSync } from "node:fs";
 import { dirname, join } from "node:path";
-import type { ArchitectureSlice, EpicState, ExtensionAPI, ExtensionContext, ModuleComponent, RoadmapPhase, RoadmapState, RoadmapPhaseModule } from "./architect-lib/types.ts";
+import type { ArchitectureSlice, EpicState, ExtensionAPI, ExtensionContext, ModuleComponent, RoadmapPhase } from "./architect-lib/types.ts";
 import {
 	ARCH_MODULES_DIR,
 	commandExists,
@@ -22,7 +22,6 @@ import {
 	loadRoadmapState,
 	parseModuleFile,
 	parseRoadmap,
-	readGroupId,
 	readRepository,
 	readLanguage,
 	readRepoTool,
@@ -176,14 +175,19 @@ class EpicManager {
 			}
 		}
 
-		// Loud warning if GitLab remote setup failed
-		if (repoTool === "glab" && !hasRemote) {
-			console.warn(
-				"⚠️  GitLab remote repo setup failed. Pipeline will run LOCAL-ONLY."
-				+ " Issues will be created as local .md files, not on GitLab."
-				+ " Check that the repository path in guardian-manifest.json exists"
-				+ " and your GitLab token has 'write_repository' scope.",
+		// Abort if remote setup was required but failed
+		// (repoTool=glab or gh means the user explicitly chose GitHub/GitLab)
+		if (!hasRemote && repoTool !== "local") {
+			console.error(
+				`✖ Remote setup failed for "${targetRepo}" (repoTool: "${repoTool}").`
+				+ "\n\n  To fix:"
+				+ "\n  1. Ensure glab/gh CLI is authenticated (glab auth status / gh auth status)"
+				+ `\n  2. Verify "${targetRepo}" is a valid repository path`
+				+ "\n  3. Or set repoTool: \"local\" in guardian-manifest.json for local-only mode"
+				+ "\n",
 			);
+			ctx.ui.notify("Epic aborted — remote setup failed. Set repoTool: \"local\" to run without a remote forge.", "error");
+			return null as unknown as EpicState;
 		}
 
 		const issues: { id: string; title: string; status: string; remoteIssueId?: string | null }[] = [];
@@ -241,7 +245,7 @@ class EpicManager {
 			status: "planned",
 			remoteIssueId: null as string | null,
 		};
-		const freezeMarkdown = generateContractFreezeMarkdown(slice, name);
+		const freezeMarkdown = generateContractFreezeMarkdown(slice, name, undefined, this.cwd);
 		writeFileSync(join(issuesDir, `${freezeId}.md`), freezeMarkdown);
 		if (hasRemote && remoteRepo) {
 			const result = createRemoteIssue(this.cwd, freezeEntry.title, join(issuesDir, `${freezeId}.md`), "epic,contract", remoteRepo);
@@ -255,14 +259,15 @@ class EpicManager {
 		// 2. Implementation issues
 		for (let i = 0; i < slice.nextLogicalSlice.length; i++) {
 			const comp = slice.nextLogicalSlice[i];
+			const moduleId = slice.module.replace(/^module-/, "");
 			const id = `issue-${comp.name.toLowerCase().replace(/[^a-z0-9]+/g, "-")}`;
 			const entry = {
 				id,
-				title: `${comp.name}: ${comp.description.slice(0, 80)}`,
+				title: `Implement ${comp.name} — ${moduleId}`,
 				status: "planned" as string,
 				remoteIssueId: null as string | null,
 			};
-			const md = generateIssueMarkdown(comp, slice, i, slice.nextLogicalSlice.length, tdd);
+			const md = generateIssueMarkdown(comp, slice, i, slice.nextLogicalSlice.length, tdd, this.cwd);
 			writeFileSync(join(issuesDir, `${id}.md`), md);
 			if (hasRemote && remoteRepo) {
 				const result = createRemoteIssue(this.cwd, entry.title, join(issuesDir, `${id}.md`), "epic,implementation", remoteRepo);

package/templates/pi/extensions/goal-loop.ts

@@ -23,53 +23,10 @@
  *   /subgoal clear        Remove all subgoals
  */
 
+import { execFileSync, execSync } from "node:child_process";
 import { existsSync, mkdirSync, readFileSync, readdirSync, writeFileSync } from "node:fs";
 import { dirname, join } from "node:path";
-
-// ── Types ──
-
-type ExtensionContext = {
-	cwd: string;
-	ui: {
-		notify(message: string, level?: string): void;
-		setStatus(key: string, message: string | null): void;
-		confirm(title: string, message: string): Promise<boolean>;
-	};
-	shell: {
-		execute(
-			command: string,
-			options?: { signal?: AbortSignal },
-		): Promise<{
-			exitCode: number;
-			stdout: string;
-		}>;
-	};
-	tools: { execute(name: string, params: Record<string, unknown>): Promise<unknown> };
-};
-
-type ExtensionAPI = {
-	on(event: string, handler: (event: unknown, ctx: ExtensionContext) => void | Promise<void>): void;
-	registerTool(options: {
-		name: string;
-		label: string;
-		description: string;
-		parameters: unknown;
-		execute(
-			toolCallId: string,
-			params: Record<string, unknown>,
-			signal: AbortSignal,
-			onUpdate: (update: { type: string; message: string }) => void,
-			ctx: ExtensionContext,
-		): unknown | Promise<unknown>;
-	}): void;
-	registerCommand(
-		name: string,
-		options: {
-			description: string;
-			handler(args: string, ctx: ExtensionContext): unknown | Promise<unknown>;
-		},
-	): void;
-};
+import type { ExtensionAPI, ExtensionContext, ExecResult } from "@earendil-works/pi-coding-agent";
 
 type GoalState = {
 	goal: string;
@@ -185,10 +142,10 @@ const BUILTIN_NAMES = Object.keys(BUILTIN_VALIDATORS);
 // ── Validator-Backed Judge ──
 
 async function runValidatorsForGoal(
-	ctx: ExtensionContext,
+	cwd: string,
 	validators: string[] = ["ci", "canonical"],
 ): Promise<{ pass: boolean; failures: string[]; results: Record<string, boolean> }> {
-	const registry = getAllValidators(ctx.cwd);
+	const registry = getAllValidators(cwd);
 	const results: Record<string, boolean> = {};
 	const failures: string[] = [];
 
@@ -199,21 +156,22 @@ async function runValidatorsForGoal(
 			failures.push(`${name}: unknown validator`);
 			continue;
 		}
-		const fullPath = join(ctx.cwd, relPath);
+		const fullPath = join(cwd, relPath);
 		if (!existsSync(fullPath)) {
 			results[name] = true; // missing script = skip = pass
 			continue;
 		}
 		try {
-			const r = await ctx.shell.execute(`bash ${relPath}`, {
-				signal: AbortSignal.timeout(60_000),
+			execFileSync("bash", [relPath], {
+				cwd,
+				timeout: 60_000,
+				encoding: "utf-8",
+				stdio: ["pipe", "pipe", "pipe"],
 			});
-			const passed = r.exitCode === 0;
-			results[name] = passed;
-			if (!passed) failures.push(`${name}: validator failed`);
+			results[name] = true;
 		} catch {
 			results[name] = false;
-			failures.push(`${name}: timeout or error`);
+			failures.push(`${name}: validator failed or timed out`);
 		}
 	}
 
@@ -221,7 +179,6 @@ async function runValidatorsForGoal(
 }
 
 async function runLLMJudge(
-	ctx: ExtensionContext,
 	goal: string,
 	lastResponse: string,
 	subgoals: string[],
@@ -236,16 +193,9 @@ async function runLLMJudge(
 
 	const prompt = `Goal:\n${truncatedGoal}\n${subgoalsBlock}\n\nAgent's most recent response:\n${truncatedResponse}\n\nIs the goal satisfied?`;
 
-	// Use guardian_coordinate to run an LLM-based judgment
-	try {
-		const result = await ctx.tools.execute("guardian_scope", {});
-		// We can't directly call LLM from extension — instead return a heuristic judgment
-		// The LLM judge runs via the agent itself being prompted to self-assess
-		// For now, return continue to let the agent decide
-		return { done: false, reason: "LLM judge requires agent self-assessment turn" };
-	} catch {
-		return { done: false, reason: "judge unavailable, continuing" };
-	}
+	// LLM judge runs via the agent itself being prompted to self-assess
+	// For now, return continue to let the agent decide
+	return { done: false, reason: "LLM judge requires agent self-assessment turn" };
 }
 
 function truncate(text: string, limit: number): string {
@@ -399,7 +349,7 @@ class GoalManager {
 
 		// Step 1: Run deterministic validators (per-goal list, or fallback)
 		const validatorsToRun = state.validators.length > 0 ? state.validators : ["ci", "canonical"];
-		const valResult = await runValidatorsForGoal(ctx, validatorsToRun);
+		const valResult = await runValidatorsForGoal(ctx.cwd, validatorsToRun);
 		state.validatorResults = {};
 		for (const [name, passed] of Object.entries(valResult.results)) {
 			state.validatorResults[name] = { passed, lastRun: new Date().toISOString() };
@@ -433,7 +383,7 @@ class GoalManager {
 
 		// Step 2: LLM semantic judge (via ask the agent to self-assess)
 		// We inject a self-assessment prompt into the continuation
-		const llmResult = await runLLMJudge(ctx, state.goal, lastResponse, state.subgoals);
+		const llmResult = await runLLMJudge(state.goal, lastResponse, state.subgoals);
 
 		if (llmResult.done) {
 			state.status = "done";

package/templates/pi/extensions/pipeline.ts

@@ -345,14 +345,14 @@ class PipelineManager {
 
 	private gitBranchExists(branch: string): boolean {
 		try {
-			const result = execSync(`git branch -a --list "${branch}" 2>/dev/null`, { cwd: this.cwd, encoding: "utf-8" });
+			const result = execFileSync("git", ["branch", "-a", "--list", branch], { cwd: this.cwd, encoding: "utf-8", stdio: ["ignore", "pipe", "ignore"] });
 			return result.trim().length > 0;
 		} catch { return false; }
 	}
 
 	private branchHasCommits(branch: string): boolean {
 		try {
-			const result = execSync(`git log --oneline "${branch}" 2>/dev/null | head -1`, { cwd: this.cwd, encoding: "utf-8" });
+			const result = execFileSync("git", ["log", "--oneline", branch], { cwd: this.cwd, encoding: "utf-8", stdio: ["ignore", "pipe", "ignore"] });
 			return result.trim().length > 0;
 		} catch { return false; }
 	}
@@ -624,7 +624,7 @@ class PipelineManager {
 
 		if (acceptance.type === "shell") {
 			try {
-				execSync(`bash -c "${acceptance.command}"`, { cwd: this.cwd, timeout: 300_000, encoding: "utf-8" });
+				execFileSync("bash", ["-c", acceptance.command], { cwd: this.cwd, timeout: 300_000, encoding: "utf-8" });
 				return { allPassed: true, errors: [] };
 			} catch (e: unknown) {
 				const err = e as { stdout?: string };
@@ -637,7 +637,7 @@ class PipelineManager {
 				const scriptPath = VALIDATOR_SCRIPTS[validator];
 				if (!scriptPath) { errors.push(`Unknown validator: ${validator}`); continue; }
 				try {
-					execSync(`bash -c "${scriptPath}"`, { cwd: this.cwd, timeout: 120_000, encoding: "utf-8" });
+					execFileSync("bash", ["-c", scriptPath], { cwd: this.cwd, timeout: 120_000, encoding: "utf-8" });
 				} catch (e: unknown) {
 					const err = e as { stdout?: string };
 					errors.push(`${validator}: ${(err.stdout || "").slice(0, 200)}`);
@@ -908,26 +908,6 @@ export default function (pi: ExtensionAPI) {
 
 			// Pipeline complete
 			if (updatedState.currentItemIndex >= updatedState.items.length) {
-				// Non-blocking: close tracking issue and epic on pipeline completion
-				try {
-					const epicStatePath = join(ctx.cwd, ".pi/.guardian-epic-state.json");
-					if (existsSync(epicStatePath)) {
-						const epicState = JSON.parse(readFileSync(epicStatePath, "utf-8")) as {
-							trackingIssueId?: string | null;
-							epicId?: string | null;
-						};
-						if (epicState.trackingIssueId && !epicState.trackingIssueId.startsWith("local:")) {
-							const closeEpicScript = join(ctx.cwd, ".pi/scripts/git/close-epic.sh");
-							if (existsSync(closeEpicScript)) {
-								const args: string[] = [closeEpicScript, "--tracking-id", epicState.trackingIssueId];
-								if (epicState.epicId) args.push("--epic-id", epicState.epicId);
-								execFileSync("bash", args, {
-									cwd: ctx.cwd, timeout: 30_000, encoding: "utf-8", stdio: "ignore",
-								});
-							}
-						}
-					}
-				} catch { /* non-blocking */ }
 				return {
 					content: [{
 						type: "text" as const,
@@ -941,7 +921,7 @@ export default function (pi: ExtensionAPI) {
 			const movedToNextItem = updatedState.currentItemIndex !== prevItemIndex;
 
 			// If we moved to a new item (completed all steps of previous item),
-			// close its remote issue
+			// close its remote issue and inject the full next-task prompt
 			if (movedToNextItem) {
 				// Close remote issue for the completed item
 				try {
@@ -962,21 +942,50 @@ export default function (pi: ExtensionAPI) {
 						}
 					}
 				} catch { /* non-blocking */ }
+
+				// If the pipeline is fully complete, close tracking issue and epic too
+				if (updatedState.currentItemIndex >= updatedState.items.length) {
+					try {
+						const epicStatePath = join(ctx.cwd, ".pi/.guardian-epic-state.json");
+						if (existsSync(epicStatePath)) {
+							const epicState = JSON.parse(readFileSync(epicStatePath, "utf-8")) as {
+								trackingIssueId?: string | null;
+								epicId?: string | null;
+							};
+							if (epicState.trackingIssueId && !epicState.trackingIssueId.startsWith("local:")) {
+								const closeEpicScript = join(ctx.cwd, ".pi/scripts/git/close-epic.sh");
+								if (existsSync(closeEpicScript)) {
+									const args: string[] = [closeEpicScript, "--tracking-id", epicState.trackingIssueId];
+									if (epicState.epicId) args.push("--epic-id", epicState.epicId);
+									execFileSync("bash", args, {
+										cwd: ctx.cwd, timeout: 30_000, encoding: "utf-8", stdio: "ignore",
+									});
+								}
+							}
+						}
+					} catch { /* non-blocking */ }
+				}
 			}
 
 			// If we moved to a new item and the next step is implement,
 			// inject the full next-task prompt with issue context
 			if (movedToNextItem && currentStep?.name === "implement") {
-				// Find the remote issue ID from epic state
+				// Load epic state for TDD context and remote issue ID
+				let epicTdd = false;
+				let epicTddTestFiles: string[] = [];
 				let remoteId: string | null | undefined;
 				try {
 					const epicStatePath = join(ctx.cwd, ".pi/.guardian-epic-state.json");
 					if (existsSync(epicStatePath)) {
 						const epicState = JSON.parse(readFileSync(epicStatePath, "utf-8")) as {
 							issues?: { id: string; remoteIssueId?: string | null }[];
+							tdd?: boolean;
+							tddTestFiles?: string[];
 						};
 						const issue = epicState.issues?.find((i) => i.id === currentItem);
 						remoteId = issue?.remoteIssueId;
+						epicTdd = epicState.tdd ?? false;
+						epicTddTestFiles = epicState.tddTestFiles ?? [];
 					}
 				} catch {
 					// ignore
@@ -988,6 +997,19 @@ export default function (pi: ExtensionAPI) {
 					remoteId,
 				);
 
+				const tddAdvanceBlock = epicTdd
+					? [
+						"",
+						"## TDD: Red-Green-Refactor",
+						"",
+						"Failing tests already exist for this component. Follow TDD:",
+						"1. **RED:** Run the failing tests first to confirm they fail",
+						"2. **GREEN:** Write minimal implementation to make tests pass",
+						"3. **REFACTOR:** Clean up while keeping tests green",
+						"",
+					].join("\n")
+					: "";
+
 				const instructions = [
 					`## Pipeline: Moving to next item`,
 					"",
@@ -996,10 +1018,13 @@ export default function (pi: ExtensionAPI) {
 					`**Issue:** ${issueSource}`,
 					"",
 					`**Next task:** Item "${currentItem}" → Step: implement`,
+					tddAdvanceBlock,
 					"",
 					"**Instructions:**",
 					"1. Review the issue context below",
-					"2. Implement the component according to the issue spec",
+					epicTdd
+						? "2. Run the pre-generated failing tests to confirm RED phase"
+						: "2. Implement the component according to the issue spec",
 					"3. Run `pipeline_run_acceptance` to validate",
 					"4. Call `pipeline_advance` when done",
 					"",
@@ -1142,16 +1167,22 @@ export default function (pi: ExtensionAPI) {
 			const step = state.steps[state.currentStepIndex];
 			if (!step) return { content: [{ type: "text" as const, text: "No more steps." }] };
 
-			// Find the remote issue ID from epic state
+			// Load epic state for TDD context and remote issue ID
+			let epicTdd = false;
+			let epicTddTestFiles: string[] = [];
 			let remoteId: string | null | undefined;
 			try {
 				const epicStatePath = join(ctx.cwd, ".pi/.guardian-epic-state.json");
 				if (existsSync(epicStatePath)) {
 					const epicState = JSON.parse(readFileSync(epicStatePath, "utf-8")) as {
 						issues?: { id: string; remoteIssueId?: string | null }[];
+						tdd?: boolean;
+						tddTestFiles?: string[];
 					};
 					const issue = epicState.issues?.find((i) => i.id === issueId);
 					remoteId = issue?.remoteIssueId;
+					epicTdd = epicState.tdd ?? false;
+					epicTddTestFiles = epicState.tddTestFiles ?? [];
 				}
 			} catch {
 				// ignore
@@ -1173,6 +1204,29 @@ export default function (pi: ExtensionAPI) {
 				}
 			}
 
+			const tddBlock = epicTdd
+				? [
+					"",
+					"---",
+					"",
+					"## TDD: Red-Green-Refactor",
+					"",
+					"Failing test files have already been generated. Follow TDD discipline:",
+					"",
+					"**1. RED — Run the failing tests first:**",
+					...epicTddTestFiles.map((f) => `  - \`${f}\``),
+					"",
+					"**2. GREEN — Implement the minimum code to make tests pass:**",
+					"  - Do NOT write new test files — the tests already exist",
+					"  - Focus on the implementation only",
+					"  - Run tests after each change to track progress",
+					"",
+					"**3. REFACTOR — Clean up while keeping tests green:**",
+					"  - Extract helpers, improve naming, remove duplication",
+					"",
+				].join("\n")
+				: "";
+
 			const text = [
 				"## Pipeline Task",
 				"",
@@ -1184,6 +1238,7 @@ export default function (pi: ExtensionAPI) {
 				"---",
 				"",
 				stepPrompt || "",
+				tddBlock,
 				"",
 				"---",
 				"",
@@ -1240,7 +1295,7 @@ export default function (pi: ExtensionAPI) {
 					return { content: [{ type: "text" as const, text: lines.join("\n") }] };
 				}
 				try {
-					const output = execSync("bash " + scriptPath, {
+					const output = execFileSync("bash", [scriptPath], {
 						cwd: ctx.cwd,
 						timeout: 300_000,
 						encoding: "utf-8",
@@ -1279,7 +1334,7 @@ export default function (pi: ExtensionAPI) {
 					continue;
 				}
 				try {
-					execSync(`bash -c "${scriptPath}"`, {
+					execFileSync("bash", ["-c", scriptPath], {
 						cwd: ctx.cwd,
 						timeout: 120_000,
 						encoding: "utf-8",

package/templates/pi/extensions/tsconfig.json

@@ -0,0 +1,15 @@
+{
+	"compilerOptions": {
+		"types": ["bun-types"],
+		"strict": true,
+		"target": "ES2022",
+		"module": "ESNext",
+		"moduleResolution": "bundler",
+		"esModuleInterop": true,
+		"skipLibCheck": true,
+		"noEmit": true,
+		"isolatedModules": true,
+		"allowImportingTsExtensions": true
+	},
+	"include": ["**/*.ts"]
+}

package/templates/pi/preflight_report.json

@@ -1,5 +1,5 @@
 {
-  "timestamp": "2026-07-13T13:10:35Z",
+  "timestamp": "2026-07-16T09:34:57Z",
   "mode": "all",
   "stages_run": [],
   "summary": {

package/templates/pi/scripts/ci/check_architecture_conformance.sh

@@ -35,21 +35,21 @@ declare -a FAILURES=()
 
 log_pass() {
     echo -e "  ${GREEN}✓ PASS${NC} $1"
-    ((PASS_COUNT++))
-    ((TOTAL_COUNT++))
+    PASS_COUNT=$((PASS_COUNT + 1))
+    TOTAL_COUNT=$((TOTAL_COUNT + 1))
 }
 
 log_fail() {
     echo -e "  ${RED}✗ FAIL${NC} $1 — $2"
-    ((FAIL_COUNT++))
-    ((TOTAL_COUNT++))
+    FAIL_COUNT=$((FAIL_COUNT + 1))
+    TOTAL_COUNT=$((TOTAL_COUNT + 1))
     FAILURES+=("$1: $2")
 }
 
 log_skip() {
     echo -e "  ${YELLOW}⊘ SKIP${NC} $1 — $2"
-    ((SKIP_COUNT++))
-    ((TOTAL_COUNT++))
+    SKIP_COUNT=$((SKIP_COUNT + 1))
+    TOTAL_COUNT=$((TOTAL_COUNT + 1))
 }
 
 # ── Language Detection ──

package/templates/pi/scripts/validate-architecture-readiness.sh

@@ -23,9 +23,9 @@ NC='\033[0m'
 PASS=0
 FAIL=0
 
-log_pass() { echo -e "  ${GREEN}✓ PASS${NC} $1"; ((PASS++)); }
-log_fail() { echo -e "  ${RED}✗ FAIL${NC} $1 — $2"; ((FAIL++)); }
-log_skip() { echo -e "  ${YELLOW}⊘ SKIP${NC} $1 — $2"; ((PASS++)); }
+log_pass() { echo -e "  ${GREEN}✓ PASS${NC} $1"; PASS=$((PASS + 1)); }
+log_fail() { echo -e "  ${RED}✗ FAIL${NC} $1 — $2"; FAIL=$((FAIL + 1)); }
+log_skip() { echo -e "  ${YELLOW}⊘ SKIP${NC} $1 — $2"; PASS=$((PASS + 1)); }
 
 echo "═══ Architecture Readiness Checks ═══"
 echo ""

package/templates/pi/scripts/validate-ci.sh

@@ -18,6 +18,8 @@ detect_language() {
         echo "rust"
     elif [ -f "go.mod" ]; then
         echo "go"
+    elif [ -f "pom.xml" ] || [ -f "build.gradle" ] || [ -f "build.gradle.kts" ]; then
+        echo "java"
     elif [ -f "package.json" ]; then
         echo "typescript"
     else