@ipul-labs/forge 1.14.1 → 1.15.1

package/README.md

@@ -145,26 +145,28 @@ See [`docs/cli.md`](./docs/cli.md) for the full command reference and [`docs/cli
 
 | Variable | Required | Description |
 |---|---|---|
-| `FORGE_TOKEN` | Yes | Dashboard password — users enter this to access Forge |
+| `FORGE_TOKEN` | Yes | Dashboard password — also auto-fills the UI login form |
+| `FORGE_REPOS` | Yes | Comma-separated repo list; first entry is the primary project |
 | `SCM_PROVIDER` | — | `gitlab` (default) · `github` · `azuredevops` |
-| `FORGE_REPOS` | — | Comma-separated repo list for multi-repo support |
 | `ANTHROPIC_API_KEY` | — | Enables live model list from Anthropic; falls back to hardcoded list |
 | `FORGE_MODEL` | — | Override default model (default: `claude-sonnet-4-6`) |
-| `VITE_FORGE_TOKEN` | — | Baked into the UI — skips the token entry form on load |
 | `K8S_CLUSTER_TOKEN` | — | K8s service account token for rollout monitoring |
 | `K8S_CLUSTER_SERVER` | — | K8s API server URL |
 | `PORT` | — | HTTP server port (default: `5001`) |
 | `OPENCLAW_GATEWAY_URL` | — | Enables OpenClaw agent backend; point at your local Gateway |
 | `OPENCLAW_TOKEN` | — | Bearer token for OpenClaw Gateway auth |
 
-### GitLab (`SCM_PROVIDER=gitlab`, default)
+### Provider credentials
+
+SCM tokens can be set here **or** in the Forge Settings UI (Settings → Connections). The UI value takes precedence over env vars.
+
+#### GitLab (`SCM_PROVIDER=gitlab`, default)
 
 | Variable | Required | Description |
 |---|---|---|
-| `FORGE_GITLAB_PROJECT` | Yes | Default project path, e.g. `group/repo` |
 | `GITLAB_TOKEN` | Yes | Personal access token with `api` + `write_repository` scopes |
 
-### GitHub (`SCM_PROVIDER=github`)
+#### GitHub (`SCM_PROVIDER=github`)
 
 | Variable | Required | Description |
 |---|---|---|
@@ -173,7 +175,7 @@ See [`docs/cli.md`](./docs/cli.md) for the full command reference and [`docs/cli
 | `GITHUB_REPO` | Yes | Repository name, e.g. `web-app` |
 | `GITHUB_BASE_BRANCH` | — | Default target branch (default: `main`) |
 
-### Azure DevOps (`SCM_PROVIDER=azuredevops`)
+#### Azure DevOps (`SCM_PROVIDER=azuredevops`)
 
 | Variable | Required | Description |
 |---|---|---|
@@ -183,6 +185,14 @@ See [`docs/cli.md`](./docs/cli.md) for the full command reference and [`docs/cli
 | `AZURE_DEVOPS_REPO` | — | Git repo name (defaults to project name) |
 | `AZURE_DEVOPS_BASE_BRANCH` | — | Default target branch (default: `main`) |
 
+### Deprecated (still work as fallbacks)
+
+| Variable | Replaced by |
+|---|---|
+| `FORGE_GITLAB_PROJECT` | First entry in `FORGE_REPOS` |
+| `VITE_FORGE_TOKEN` | Auto-derived from `FORGE_TOKEN` |
+| `FORGE_REFINE_REPO_ACCESS` | Settings UI toggle (Settings → Defaults) |
+
 See `.env.example` for a full annotated list.
 
 ---

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ipul-labs/forge",
-  "version": "1.14.1",
+  "version": "1.15.1",
   "description": "AI-powered code change & deploy control panel — connects Claude, GitLab, and Kubernetes",
   "type": "module",
   "main": "server/forge/routes.js",
@@ -21,7 +21,9 @@
     "dev": "trap 'kill 0' EXIT INT TERM; FORGE_NO_VITE=1 node --watch-path=./server --watch-path=./server.js server.js & vite; wait",
     "build": "vite build",
     "start": "NODE_ENV=production node server.js",
-    "typecheck": "tsc --noEmit"
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run",
+    "test:watch": "vitest"
   },
   "dependencies": {
     "@kubernetes/client-node": "^1.0.0",
@@ -47,13 +49,14 @@
     "@types/express": "^5.0.0",
     "@types/react": "^19.0.0",
     "@types/react-dom": "^19.0.0",
-    "@vitejs/plugin-react": "^4.3.0",
+    "@vitejs/plugin-react": "^6.0.0",
     "autoprefixer": "^10.4.20",
     "postcss": "^8.4.47",
     "semantic-release": "^25.0.3",
     "tailwindcss": "^3.4.14",
     "typescript": "^5.6.0",
-    "vite": "^5.4.0"
+    "vite": "^8.0.0",
+    "vitest": "^4.1.0"
   },
   "engines": {
     "node": ">=20.0.0"

package/server/forge/core/ForgeAgent.js

@@ -26,6 +26,7 @@ import { checkResolution, identifyRelevantFiles, proposeFix, refineOrAsk } from
 import { branchNameFor } from "./branchName.js";
 import * as configStore from "./configStore.js";
 import { ensureWorkingTree, overlayChanges } from "./localRepo.js";
+import { classifyIssue } from "./prompts.js";
 import { createProvider } from "./providers/index.js";
 import { reattributeChanges } from "./validator/attribute.js";
 
@@ -100,19 +101,26 @@ function isLikelyResumeFailure(err) {
  */
 
 const MAX_FILE_BYTES = 40_000;        // ~40 KB per file to keep the context window healthy
-const MAX_FILES_TOTAL = 12;           // hard cap across all repos
-const MAX_FILES_PER_REPO = 8;         // cap per repo so one repo can't starve another
 const CONV_PREFIX = /^(?:feat|fix|chore|docs|style|refactor|perf|test|build|ci|revert)(?:\([^)]+\))?!?:\s*/i;
 
+const FILE_CAPS = {
+	feature:  { total: 18, perRepo: 15 },
+	refactor: { total: 18, perRepo: 15 },
+	fix:      { total: 12, perRepo: 8 },
+	chore:    { total: 12, perRepo: 8 },
+};
+
 /**
  * Builds a conventional-commit subject line from the analysis. Prefers
  * `analysis.mrTitle` (the model's own commit-style summary), falling back to
- * the issue title with a `fix:` prefix when the model didn't supply one.
+ * the issue title with a prefix derived from the issue kind.
  */
 function buildCommitSubject(analysis) {
 	const mrTitle = analysis.mrTitle?.trim();
 	if (mrTitle) return mrTitle;
-	return `fix: ${analysis.issue.title.replace(CONV_PREFIX, "")}`;
+	const kind = classifyIssue(analysis.issue);
+	const prefix = kind === "feature" ? "feat" : kind === "refactor" ? "refactor" : "fix";
+	return `${prefix}: ${analysis.issue.title.replace(CONV_PREFIX, "")}`;
 }
 
 /**
@@ -194,7 +202,7 @@ export class ForgeAgent {
 	 * @param {{ project?: string, secondaryProjects?: string[], agent?: string }} [opts]
 	 */
 	constructor(opts = {}) {
-		const primary = opts.project ?? process.env.FORGE_GITLAB_PROJECT;
+		const primary = opts.project ?? configStore.getPrimaryProject();
 		if (!primary) throw new Error("ForgeAgent requires a primary project.");
 
 		const secondaries = (opts.secondaryProjects ?? [])
@@ -235,7 +243,7 @@ export class ForgeAgent {
 		const results = await Promise.all(
 			this.allRepos.map(async (repo) => {
 				try {
-					const files = await this._provider(repo).getFileTree("src", "main");
+					const files = await this._provider(repo).getFileTree("", "main");
 					return { repo, files };
 				} catch (err) {
 					emit({ type: "log", message: `Could not scan ${repo}: ${err.message}` });
@@ -315,13 +323,14 @@ export class ForgeAgent {
 	}
 
 	/** Enforces the per-repo and total caps, preserving model order. */
-	_capSelections(entries) {
+	_capSelections(entries, issueKind) {
+		const caps = FILE_CAPS[issueKind] ?? FILE_CAPS.fix;
 		const capped = [];
 		const perRepo = new Map();
 		for (const entry of entries) {
-			if (capped.length >= MAX_FILES_TOTAL) break;
+			if (capped.length >= caps.total) break;
 			const count = perRepo.get(entry.repo) ?? 0;
-			if (count >= MAX_FILES_PER_REPO) continue;
+			if (count >= caps.perRepo) continue;
 			capped.push(entry);
 			perRepo.set(entry.repo, count + 1);
 		}
@@ -391,9 +400,12 @@ export class ForgeAgent {
 			cacheReadTokens: cr1 = 0,
 		} = ident;
 
+		const issueKind = classifyIssue(issue);
+		emit({ type: "log", message: `Issue classified as: ${issueKind}` });
+
 		const normalized = this._normalizeFileSelections(rawFiles);
 		const { valid, skipped } = this._validateSelections(normalized, repoTrees);
-		const capped = this._capSelections(valid);
+		const capped = this._capSelections(valid, issueKind);
 
 		if (capped.length) {
 			emit({ type: "log", message: `Identified ${capped.length} file(s): ${capped.map((f) => `${f.repo}:${f.path}`).join(", ")}` });
@@ -413,10 +425,11 @@ export class ForgeAgent {
 
 		// Step 5 — propose fix (pass 2)
 		emit({ type: "progress", step: "generate_fix", message: msgs.generate_fix });
+		const promptRules = configStore.get().defaults?.promptRules || "";
 		const propose = await proposeFix(
 			issue,
 			fileContents,
-			{ ciContext, userPrompt, previousChanges, repos: this.allRepos },
+			{ ciContext, userPrompt, previousChanges, repos: this.allRepos, promptRules },
 			model,
 			this.agent,
 			{ signal },
@@ -425,6 +438,7 @@ export class ForgeAgent {
 			title: mrTitle,
 			explanation,
 			changes,
+			removals = [],
 			cost: cost2 = 0,
 			inputTokens: it2 = 0,
 			outputTokens: ot2 = 0,
@@ -438,6 +452,12 @@ export class ForgeAgent {
 			type: "log",
 			message: `Proposed ${enrichedChanges.length} change(s): ${enrichedChanges.map((c) => `${c.repo}:${c.file} (${c.action})`).join(", ")}`,
 		});
+		if (removals.length > 0) {
+			emit({
+				type: "log",
+				message: `⚠ ${removals.length} removal(s) declared: ${removals.map((r) => `${r.file}: ${r.what}`).join("; ")}`,
+			});
+		}
 
 		const result = {
 			issue,
@@ -445,6 +465,7 @@ export class ForgeAgent {
 			explanation,
 			reasoning,
 			changes: enrichedChanges,
+			removals,
 			repos: this.allRepos,
 		};
 		emit({ type: "result", data: result });
@@ -506,10 +527,11 @@ export class ForgeAgent {
 		// the caller expects fresh changes.
 		if (ciContext) {
 			emit({ type: "progress", step: "generate_fix", message: `Fixing CI failure with ${this._agentLabel}...` });
+			const ciRefineRules = configStore.get().defaults?.promptRules || "";
 			const propose = await proposeFix(
 				issue,
 				fileContents,
-				{ feedback, previousChanges, ciContext, repos: this.allRepos },
+				{ feedback, previousChanges, ciContext, repos: this.allRepos, promptRules: ciRefineRules },
 				model,
 				this.agent,
 				{ signal },
@@ -567,6 +589,7 @@ export class ForgeAgent {
 		emit({ type: "progress", step: "generate_fix", message: `Refining fix with ${this._agentLabel}...` });
 		if (sessionId) emit({ type: "session", sessionId, resumed: resumeSession });
 
+		const refinePromptRules = configStore.get().defaults?.promptRules || "";
 		const callRefine = (sid, resume) =>
 			refineOrAsk(
 				issue,
@@ -579,6 +602,7 @@ export class ForgeAgent {
 					repoCwd,
 					repoTrees,
 					repoAccessMode: repoCwd ? "tools" : "tree",
+					promptRules: refinePromptRules,
 					...(sid ? { sessionId: sid, resumeSession: resume } : {}),
 				},
 				model,
@@ -735,7 +759,7 @@ export class ForgeAgent {
 		} = ident;
 
 		const { valid } = this._validateSelections(this._normalizeFileSelections(rawFiles), repoTrees);
-		const capped = this._capSelections(valid);
+		const capped = this._capSelections(valid, "fix");
 
 		emit({
 			type: "progress",
@@ -745,10 +769,11 @@ export class ForgeAgent {
 		const fileContents = await this._fetchFiles(capped, emit);
 
 		emit({ type: "progress", step: "generate_fix", message: `Fixing CI failure with ${this._agentLabel}...` });
+		const ciPromptRules = configStore.get().defaults?.promptRules || "";
 		const propose = await proposeFix(
 			issue,
 			fileContents,
-			{ ciContext, repos: this.allRepos },
+			{ ciContext, repos: this.allRepos, promptRules: ciPromptRules },
 			model,
 			this.agent,
 			{ signal },

package/server/forge/core/ForgeAgent.test.js

@@ -0,0 +1,179 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+
+// We test the module-level helpers and ForgeAgent internals by importing the
+// module. The class constructor requires a project, so we mock the provider.
+// For the pure functions (buildCommitSubject, FILE_CAPS), we test them through
+// a thin wrapper or by constructing a ForgeAgent with mocked providers.
+
+// ─── Module-level helpers ────────────────────────────────────────────────────
+
+// buildCommitSubject and FILE_CAPS are not exported, so we test them through
+// ForgeAgent's public surface or by importing the module and inspecting.
+// Since they're internal, we test via the class methods that use them.
+
+import * as configStore from "./configStore.js";
+
+// Mock configStore.getPrimaryProject for ForgeAgent constructor
+vi.spyOn(configStore, "getPrimaryProject").mockReturnValue("group/web-app");
+vi.spyOn(configStore, "get").mockReturnValue({
+	repos: [{ id: "group/web-app", label: "web-app" }],
+	defaults: { promptRules: "" },
+	connections: {},
+});
+
+// Mock the provider factory
+vi.mock("./providers/index.js", () => ({
+	createProvider: () => ({
+		getIssue: vi.fn(),
+		getFileTree: vi.fn().mockResolvedValue([]),
+		getFileContent: vi.fn(),
+		createBranch: vi.fn(),
+		commitFiles: vi.fn(),
+		createMR: vi.fn(),
+		listAllForgeMRs: vi.fn().mockResolvedValue([]),
+		getMRPipelines: vi.fn().mockResolvedValue([]),
+	}),
+}));
+
+// Dynamic import after mocks are set up
+const { ForgeAgent } = await import("./ForgeAgent.js");
+
+describe("ForgeAgent", () => {
+	describe("_capSelections", () => {
+		let agent;
+
+		beforeEach(() => {
+			agent = new ForgeAgent({ project: "group/web-app" });
+		});
+
+		it("applies fix caps (12 total, 8 per repo)", () => {
+			const entries = Array.from({ length: 15 }, (_, i) => ({
+				repo: "group/web-app",
+				path: `src/file${i}.ts`,
+			}));
+
+			const capped = agent._capSelections(entries, "fix");
+			expect(capped).toHaveLength(8);
+		});
+
+		it("applies feature caps (18 total, 15 per repo)", () => {
+			const entries = Array.from({ length: 20 }, (_, i) => ({
+				repo: "group/web-app",
+				path: `src/file${i}.ts`,
+			}));
+
+			const capped = agent._capSelections(entries, "feature");
+			expect(capped).toHaveLength(15);
+		});
+
+		it("enforces total cap across multiple repos for features", () => {
+			const entries = [
+				...Array.from({ length: 12 }, (_, i) => ({
+					repo: "group/web-app",
+					path: `src/file${i}.ts`,
+				})),
+				...Array.from({ length: 12 }, (_, i) => ({
+					repo: "group/api",
+					path: `internal/file${i}.go`,
+				})),
+			];
+
+			const capped = agent._capSelections(entries, "feature");
+			expect(capped).toHaveLength(18);
+		});
+
+		it("defaults to fix caps for unknown kinds", () => {
+			const entries = Array.from({ length: 15 }, (_, i) => ({
+				repo: "group/web-app",
+				path: `src/file${i}.ts`,
+			}));
+
+			const capped = agent._capSelections(entries, "unknown");
+			expect(capped).toHaveLength(8);
+		});
+
+		it("refactor gets same caps as feature", () => {
+			const entries = Array.from({ length: 20 }, (_, i) => ({
+				repo: "group/web-app",
+				path: `src/file${i}.ts`,
+			}));
+
+			const capped = agent._capSelections(entries, "refactor");
+			expect(capped).toHaveLength(15);
+		});
+	});
+
+	describe("_normalizeFileSelections", () => {
+		let agent;
+
+		beforeEach(() => {
+			agent = new ForgeAgent({ project: "group/web-app" });
+		});
+
+		it("normalizes string entries to primary repo", () => {
+			const result = agent._normalizeFileSelections(["src/App.tsx"]);
+			expect(result).toEqual([{ repo: "group/web-app", path: "src/App.tsx" }]);
+		});
+
+		it("passes through {repo, path} objects", () => {
+			const result = agent._normalizeFileSelections([
+				{ repo: "group/api", path: "main.go" },
+			]);
+			expect(result).toEqual([{ repo: "group/api", path: "main.go" }]);
+		});
+
+		it("defaults repo when only path is present", () => {
+			const result = agent._normalizeFileSelections([{ path: "src/a.ts" }]);
+			expect(result).toEqual([{ repo: "group/web-app", path: "src/a.ts" }]);
+		});
+
+		it("filters out null and invalid entries", () => {
+			const result = agent._normalizeFileSelections([null, undefined, {}, "src/a.ts"]);
+			expect(result).toHaveLength(1);
+			expect(result[0].path).toBe("src/a.ts");
+		});
+	});
+
+	describe("_validateSelections", () => {
+		let agent;
+
+		beforeEach(() => {
+			agent = new ForgeAgent({ project: "group/web-app" });
+		});
+
+		it("keeps files that exist in the tree", () => {
+			const entries = [{ repo: "group/web-app", path: "src/App.tsx" }];
+			const trees = [{ repo: "group/web-app", files: ["src/App.tsx", "src/index.ts"] }];
+			const { valid, skipped } = agent._validateSelections(entries, trees);
+			expect(valid).toHaveLength(1);
+			expect(skipped).toHaveLength(0);
+		});
+
+		it("skips files not in the tree", () => {
+			const entries = [{ repo: "group/web-app", path: "src/Missing.tsx" }];
+			const trees = [{ repo: "group/web-app", files: ["src/App.tsx"] }];
+			const { valid, skipped } = agent._validateSelections(entries, trees);
+			expect(valid).toHaveLength(0);
+			expect(skipped).toHaveLength(1);
+			expect(skipped[0]).toContain("not in tree");
+		});
+
+		it("skips files from unknown repos", () => {
+			const entries = [{ repo: "group/unknown", path: "src/a.ts" }];
+			const trees = [{ repo: "group/web-app", files: ["src/a.ts"] }];
+			const { valid, skipped } = agent._validateSelections(entries, trees);
+			expect(valid).toHaveLength(0);
+			expect(skipped[0]).toContain("unknown repo");
+		});
+
+		it("deduplicates entries", () => {
+			const entries = [
+				{ repo: "group/web-app", path: "src/App.tsx" },
+				{ repo: "group/web-app", path: "src/App.tsx" },
+			];
+			const trees = [{ repo: "group/web-app", files: ["src/App.tsx"] }];
+			const { valid } = agent._validateSelections(entries, trees);
+			expect(valid).toHaveLength(1);
+		});
+	});
+});

package/server/forge/core/claudeClient.js

@@ -22,6 +22,7 @@ import {
 	buildRefineOrAskPrompt,
 	buildRefineResumePrompt,
 	buildCheckResolutionPrompt,
+	classifyIssue,
 } from "./prompts.js";
 
 // FORGE_MODEL env var overrides the default. Set to a cheaper model to reduce cost.
@@ -334,10 +335,24 @@ Your final message MUST be a single raw JSON object matching the schema — no p
 
 export async function proposeFix(issue, fileContents, options = {}, model, opts = {}) {
 	const schema = options.ciContext ? CI_FIX_SCHEMA : PROPOSE_FIX_SCHEMA;
-	const { data, cost, serviceTier, inputTokens, outputTokens, cacheCreationTokens, cacheReadTokens } = await runClaude(
-		buildProposeFixPrompt(issue, fileContents, options),
-		schema,
-		`You are Forge, an AI code assistant in a production React/TypeScript/Express codebase.
+	const kind = classifyIssue(issue);
+	const isFeature = kind === "feature" || kind === "refactor";
+
+	const systemPrompt = isFeature
+		? `You are Forge, an AI code assistant in a production React/TypeScript/Express codebase.
+Rules:
+- Match the existing code style exactly (TypeScript strict, no barrel imports, Tailwind for UI).
+- For "proposed", always return the COMPLETE file content, not a diff or snippet.
+- Maximum 12 files changed. Prioritise core changes over secondary ones — if the feature touches more files than the cap, implement the most important changes and note the rest in "explanation".
+- Never add console.* — use the existing log utility.
+- Never add comments unless the logic is non-obvious.
+- Before returning, verify TypeScript correctness: no implicit any, no missing imports, no type mismatches, all imported symbols must actually be exported from their source.
+Feature discipline:
+- Follow the issue specification. Only make changes the issue asks for — do not clean up, refactor, or "improve" unrelated code.
+- When the issue says to ADD an entry to an existing list or config (nav items, routes, type unions), add the entry — do not restructure the existing code around it.
+- Base new files on the patterns and conventions visible in the relevant files.
+- Use a "feat:" conventional-commit prefix in the title, not "fix:".`
+		: `You are Forge, an AI code assistant in a production React/TypeScript/Express codebase.
 Rules:
 - Changes must be minimal and surgical.
 - Match the existing code style exactly (TypeScript strict, no barrel imports, Tailwind for UI).
@@ -350,7 +365,12 @@ Rules:
 Root-cause discipline:
 - A fix that only improves an error message or adds a guard at the point of failure is a symptom suppressor, not a fix. Reject it and find the upstream origin of the bad input.
 - When a value is undefined/null at a check, trace one or two frames up (the caller of the function, the prop passed into the component, the handler bound to an onClick). Default function parameters are defeated when the caller passes an unexpected argument (e.g. React forwarding a MouseEvent) — look for that class of bug before patching the consumer.
-- In "explanation", name the origin of the bad value and state why the reported symptom can no longer occur after your change.`,
+- In "explanation", name the origin of the bad value and state why the reported symptom can no longer occur after your change.`;
+
+	const { data, cost, serviceTier, inputTokens, outputTokens, cacheCreationTokens, cacheReadTokens } = await runClaude(
+		buildProposeFixPrompt(issue, fileContents, options),
+		schema,
+		systemPrompt,
 		model,
 		{ signal: opts.signal },
 	);

package/server/forge/core/configStore.js

@@ -30,6 +30,7 @@ import path from "node:path";
  *     agent: string | null,
  *     autoPushOnValidatePass: boolean,
  *     refineRepoAccess: boolean,
+ *     promptRules: string,
  *   },
  *   connections: {
  *     gitlab: GitLabConnection,
@@ -55,6 +56,9 @@ const DEFAULT_CONFIG = {
 		// clone of the primary repo. Off → lighter "file tree in prompt" flow.
 		// The FORGE_REFINE_REPO_ACCESS env var, when set, overrides this.
 		refineRepoAccess: true,
+		// Free-form rules injected into every analysis and refine prompt.
+		// Lets the user steer the model without touching code.
+		promptRules: "",
 		// Test-deploy URL surfaced next to "Approve & Create MR" when the
 		// branch pipeline is green. Plain URL (e.g. "https://test.example.com")
 		// for a shared env; supports "{branch}" / "{slug}" placeholders when
@@ -153,6 +157,17 @@ export function reload() {
 	return cache;
 }
 
+/**
+ * Resolves the primary project identifier.
+ * Priority: persisted config repos[0] → FORGE_REPOS first entry → FORGE_GITLAB_PROJECT.
+ */
+export function getPrimaryProject() {
+	const repos = cache.repos;
+	if (repos.length > 0) return repos[0].id;
+	const raw = process.env.FORGE_REPOS ?? process.env.FORGE_GITLAB_PROJECT ?? "";
+	return raw.split(",")[0]?.trim() || null;
+}
+
 const ENV_TOKEN_KEYS = {
 	gitlab: "GITLAB_TOKEN",
 	github: "GITHUB_TOKEN",

package/server/forge/core/configStore.test.js

@@ -0,0 +1,89 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+
+// We test getPrimaryProject and getConnection which resolve from
+// cache (configStore state) → env vars → defaults.
+
+import { getPrimaryProject, getConnection, get, reload } from "./configStore.js";
+
+describe("getPrimaryProject", () => {
+	const originalEnv = { ...process.env };
+
+	afterEach(() => {
+		process.env = { ...originalEnv };
+	});
+
+	it("returns first config repo when config has repos", () => {
+		const cfg = get();
+		// If the test env has repos in config, this tests the real path.
+		// Otherwise we test the env fallback paths below.
+		if (cfg.repos.length > 0) {
+			expect(getPrimaryProject()).toBe(cfg.repos[0].id);
+		}
+	});
+
+	it("falls back to FORGE_REPOS first entry", () => {
+		// Temporarily clear config repos by checking current state
+		const cfg = get();
+		if (cfg.repos.length === 0) {
+			process.env.FORGE_REPOS = "group/web-app,group/api";
+			expect(getPrimaryProject()).toBe("group/web-app");
+		}
+	});
+
+	it("falls back to FORGE_GITLAB_PROJECT when FORGE_REPOS is unset", () => {
+		const cfg = get();
+		if (cfg.repos.length === 0) {
+			delete process.env.FORGE_REPOS;
+			process.env.FORGE_GITLAB_PROJECT = "legacy/project";
+			expect(getPrimaryProject()).toBe("legacy/project");
+		}
+	});
+
+	it("returns null when nothing is configured", () => {
+		const cfg = get();
+		if (cfg.repos.length === 0) {
+			delete process.env.FORGE_REPOS;
+			delete process.env.FORGE_GITLAB_PROJECT;
+			expect(getPrimaryProject()).toBeNull();
+		}
+	});
+
+	it("trims whitespace from FORGE_REPOS entries", () => {
+		const cfg = get();
+		if (cfg.repos.length === 0) {
+			process.env.FORGE_REPOS = "  group/web-app , group/api ";
+			expect(getPrimaryProject()).toBe("group/web-app");
+		}
+	});
+});
+
+describe("getConnection", () => {
+	const originalEnv = { ...process.env };
+
+	afterEach(() => {
+		process.env = { ...originalEnv };
+	});
+
+	it("returns token from env when config has none", () => {
+		process.env.GITLAB_TOKEN = "test-token-123";
+		const conn = getConnection("gitlab");
+		// Config token takes precedence, so if config has one we get that.
+		// Either way, we should get a non-empty token.
+		expect(conn.token).toBeTruthy();
+	});
+
+	it("returns a baseUrl for gitlab", () => {
+		const conn = getConnection("gitlab");
+		expect(conn.baseUrl).toContain("gitlab.com");
+	});
+
+	it("returns empty token when nothing is configured", () => {
+		delete process.env.GITLAB_TOKEN;
+		const cfg = get();
+		// Only test if config also has no token
+		if (!cfg.connections?.gitlab?.token) {
+			const conn = getConnection("gitlab");
+			expect(conn.token).toBe("");
+		}
+	});
+});

package/server/forge/core/localRepo.js

@@ -18,6 +18,8 @@ import fs from "fs/promises";
 import os from "os";
 import path from "path";
 
+import { getConnection } from "./configStore.js";
+
 const CACHE_ROOT = process.env.FORGE_VALIDATE_CACHE
 	?? path.join(os.homedir(), ".forge", "cache");
 
@@ -53,8 +55,8 @@ function sanitizeRepo(repo) {
 }
 
 function gitlabCloneUrl(project) {
-	const token = process.env.GITLAB_TOKEN;
-	if (!token) throw new Error("GITLAB_TOKEN is required to clone the repo locally.");
+	const { token } = getConnection("gitlab");
+	if (!token) throw new Error("GitLab token is required to clone the repo locally. Set it in Settings → Connections or via GITLAB_TOKEN env var.");
 	return `https://oauth2:${token}@gitlab.com/${project}.git`;
 }
 

package/server/forge/core/prompts.js

@@ -148,6 +148,30 @@ export const RESOLUTION_CHECK_SCHEMA = JSON.stringify({
 	required: ["resolved", "reasoning"],
 });
 
+/**
+ * Classifies an issue as "feature", "fix", or "chore" from its title, labels,
+ * and description. Used to select the right prompt guidance and file caps.
+ *
+ * Priority: conventional-commit title prefix > labels > description heuristics > default "fix".
+ */
+export function classifyIssue(issue) {
+	const title = (issue.title ?? "").toLowerCase();
+	const labels = (issue.labels ?? []).map((l) => (typeof l === "string" ? l : l.name ?? "").toLowerCase());
+
+	if (/^feat[\s(:/!]/.test(title)) return "feature";
+	if (/^fix[\s(:/!]/.test(title)) return "fix";
+	if (/^chore[\s(:/!]/.test(title)) return "chore";
+	if (/^refactor[\s(:/!]/.test(title)) return "refactor";
+
+	if (labels.some((l) => l.includes("feature") || l.includes("enhancement"))) return "feature";
+	if (labels.some((l) => l.includes("bug") || l.includes("defect"))) return "fix";
+
+	const desc = (issue.description ?? "").toLowerCase();
+	if (desc.includes("## approach") || desc.includes("## frontend changes") || desc.includes("## backend")) return "feature";
+
+	return "fix";
+}
+
 /**
  * Builds a human-readable block listing each repo's file tree.
  * Accepts either:
@@ -198,17 +222,32 @@ export function buildIdentifyFilesPrompt(issue, repoTrees) {
 		? `\n\n## Multi-repo guidance\nThese repositories are deployed together as a full-stack application. If the issue genuinely requires coordinated changes in more than one repo (e.g. a new API endpoint in the backend AND its client in the frontend), select files from each affected repo. If the fix is self-contained, pick files from only one repo.`
 		: "";
 
+	const kind = classifyIssue(issue);
+	const isFeature = kind === "feature" || kind === "refactor";
+
+	const selectionRules = isFeature
+		? `Selection rules (feature implementation):
+- Focus on files that ALREADY EXIST and need modification to support the new feature.
+- Include files that serve as PATTERNS for new files the issue asks you to create (e.g. an existing page component when a new page route is needed, an existing hook when a new hook is needed).
+- Include shared registries and type files that need new entries (routes, nav items, type definitions, API endpoints).
+- When the issue specifies exact file paths to modify, prefer those paths.
+- Do NOT select files for changes the issue doesn't mention — follow the spec, don't invent work.
+- If the issue references an existing UI element (e.g. sidebar, navbar) and only asks to ADD an entry, select the data/config file that drives that element, not the rendering component (unless the issue explicitly says to change rendering logic).`
+		: `Selection rules (bug fix):
+- When a bug points at a failing assertion, guard, or validation (e.g. "undefined priceId", "X is not defined", "cannot read property of undefined"), include the IMMEDIATE CALLER(S) of that function — not just the file where the error is thrown. The bad value usually originates upstream.
+- When a bug points at an event handler or React component, include the component that renders the handler AND the handler's implementation.
+- Prefer fewer files over more, but never omit a caller when the reported symptom is a downstream consequence of input received from that caller.`;
+
+	const maxFiles = isFeature ? 15 : 10;
+
 	return `Respond with ONLY a raw JSON object — no markdown, no prose, no code fences.
 
 Schema: {"files": [{"repo": "<repo id>", "path": "src/foo/bar.ts"}], "reasoning": "one or two sentences"}
 
-Identify the minimum set of source files (max 10 across all repos) relevant to fixing this issue.
+Identify the ${isFeature ? "set" : "minimum set"} of source files (max ${maxFiles} across all repos) relevant to ${isFeature ? "implementing" : "fixing"} this issue.
 Always use an exact repo id from the "Available repositories" list below — do not invent or abbreviate.
 
-Selection rules:
-- When a bug points at a failing assertion, guard, or validation (e.g. "undefined priceId", "X is not defined", "cannot read property of undefined"), include the IMMEDIATE CALLER(S) of that function — not just the file where the error is thrown. The bad value usually originates upstream.
-- When a bug points at an event handler or React component, include the component that renders the handler AND the handler's implementation.
-- Prefer fewer files over more, but never omit a caller when the reported symptom is a downstream consequence of input received from that caller.
+${selectionRules}
 
 ## Issue #${issue.iid}: ${issue.title}
 ${issue.description || "(no description)"}
@@ -222,9 +261,11 @@ ${renderRepoTrees(repoTrees)}`;
 }
 
 export function buildProposeFixPrompt(issue, fileContents, options = {}) {
-	const { feedback, previousChanges, ciContext, userPrompt, repos } = options;
+	const { feedback, previousChanges, ciContext, userPrompt, repos, promptRules } = options;
 
 	const filesBlock = renderFileContents(fileContents);
+	const kind = classifyIssue(issue);
+	const isFeature = kind === "feature" || kind === "refactor";
 
 	const previousBlock = previousChanges?.length
 		? `\n\n## Previous proposed changes\n${renderPreviousChanges(previousChanges)}`
@@ -257,21 +298,46 @@ ${ciContext.trim()}`
 		? `\n\n## Multi-repo guidance\nThis is a full-stack change. If the fix requires coordinated updates in more than one repo, produce changes tagged with the correct repo for each. Make sure API shapes, types, and field names agree across repos.`
 		: "";
 
-	return `Respond with ONLY a raw JSON object — no markdown, no prose, no code fences.
-
-Schema: {"title": "fix: concise description of the actual change (max 72 chars)", "explanation": "...", "changes": [{"repo": "<repo id>", "file": "...", "action": "modify|create|delete", "proposed": "<full file content>", "summary": "..."}]}
-
-Propose a targeted fix for this issue.
+	const rulesBlock = promptRules?.trim()
+		? `\n\n## Custom rules (from project settings — always follow these)\n${promptRules.trim()}`
+		: "";
 
-Root-cause discipline (read BEFORE writing any change):
+	const titlePrefix = isFeature ? "feat" : "fix";
+	const titleExample = isFeature
+		? `"feat: add browseable mixes section with platinum-gated publishing"`
+		: `"fix: resolve token refresh race condition in AuthService"`;
+
+	const collateralGuard = `COLLATERAL DAMAGE GUARD — read BEFORE writing any "proposed" content:
+Your default when modifying a file is to PRESERVE every existing line that is not directly related to the issue. Do not silently remove, reorganize, or simplify wrapper elements, imports, sibling components, or unrelated UI features (version displays, badges, icons, etc.).
+If you believe existing code MUST be removed or restructured for the change to work, you MUST declare each removal in the top-level "removals" array. Each entry needs: the file path, a short description of what was removed, and why the removal is necessary. An empty "removals" array (or omitting it) means "I preserved everything unrelated."
+The reviewer will see these as warnings and must acknowledge them before the change can be committed — so never silently drop existing functionality.`;
+
+	const discipline = isFeature
+		? `Feature implementation rules (read BEFORE writing any change):
+1. Follow the issue specification precisely. If the issue says to modify a specific file, modify that file. If it says to create a new file, create it. Do NOT invent changes the issue doesn't ask for.
+2. When the issue references existing components or patterns to reuse, base your implementation on the existing patterns in the "Relevant files" section.
+3. For new files, follow the naming conventions, import style, and structure of the existing codebase.
+4. Be aware of existing routes, tabs, and UI sections that may OVERLAP with what you're implementing. If the issue creates a new "/mixes" route, check whether the codebase already has mixes-related UI elsewhere (e.g. a tab inside another page) and note any conflict in "explanation".
+5. In your "explanation", state (a) which existing patterns you followed, (b) what new files you created, and (c) any conflicts or considerations the reviewer should know about.
+6. ${collateralGuard}`
+		: `Root-cause discipline (read BEFORE writing any change):
 1. Identify the ORIGIN of the bad value, not just where it's observed. If a guard, assertion, or validation is failing, trace the value one or two frames up and name the caller that produced the bad input.
 2. A fix that only makes an error message clearer (e.g. replacing \`assertIsDefined(x)\` with \`if (!x) toast.error(…)\`) is NOT a fix — it is a symptom suppressor. Reject it and propose the upstream fix instead.
 3. In your "explanation", state (a) where the bad value originates, (b) why the fix closes the reported symptom end-to-end, and (c) what would have to be true for the reported error to still appear after your change.
 4. If the origin is in a file that was not selected in pass 1, your "changes" should include that file. Do not constrain yourself to only the files listed under "Relevant files" when doing so would force a symptom-level patch.
+5. ${collateralGuard}`;
+
+	return `Respond with ONLY a raw JSON object — no markdown, no prose, no code fences.
+
+Schema: {"title": "${titlePrefix}: concise description of the actual change (max 72 chars)", "explanation": "...", "changes": [{"repo": "<repo id>", "file": "...", "action": "modify|create|delete", "proposed": "<full file content>", "summary": "..."}], "removals": [{"file": "...", "what": "short description of removed code", "why": "reason this removal is necessary"}]}
+
+${isFeature ? "Implement this feature." : "Propose a targeted fix for this issue."}
+
+${discipline}
 
 ## Issue #${issue.iid}: ${issue.title}
 ${issue.description || "(no description)"}
-Labels: ${issue.labels?.join(", ") || "none"}${reposLine}${multiNote}${previousBlock}${feedbackBlock}${ciBlock}${userBlock}
+Labels: ${issue.labels?.join(", ") || "none"}${reposLine}${multiNote}${rulesBlock}${previousBlock}${feedbackBlock}${ciBlock}${userBlock}
 
 ## Relevant files
 ${filesBlock}`;
@@ -308,7 +374,7 @@ function renderValidationState(state) {
  * responds with EITHER a grounded answer OR a fresh changes[] payload.
  */
 export function buildRefineOrAskPrompt(issue, fileContents, options = {}) {
-	const { feedback, previousChanges, validationState, repos, repoTrees, repoAccessMode } = options;
+	const { feedback, previousChanges, validationState, repos, repoTrees, repoAccessMode, promptRules } = options;
 
 	const filesBlock = renderFileContents(fileContents);
 	const previousBlock = previousChanges?.length
@@ -327,6 +393,10 @@ export function buildRefineOrAskPrompt(issue, fileContents, options = {}) {
 		? `\n\n## Repo access\nThe current working directory is a checkout of the primary repo with the proposed changes already overlaid. Use the Read, Glob, and Grep tools to inspect any file you need before answering or refining. Do NOT claim you lack repo access.`
 		: `\n\n## Repo access\nYou have the full file tree above and the complete content of every file currently in scope. Treat these as authoritative. If you need a file not attached, name the path and ask the user to share it — do NOT claim you lack repo access.`;
 
+	const rulesBlock = promptRules?.trim()
+		? `\n\n## Custom rules (from project settings — always follow these)\n${promptRules.trim()}`
+		: "";
+
 	return `Respond with ONLY a raw JSON object — no markdown, no prose, no code fences.
 
 Schema: {
@@ -356,7 +426,7 @@ If the message is ambiguous, prefer "answer" and ask a clarifying question.
 
 ## Issue #${issue.iid}: ${issue.title}
 ${issue.description || "(no description)"}
-Labels: ${issue.labels?.join(", ") || "none"}${reposLine}${accessBlock}${treeBlock}${previousBlock}${validationBlock}
+Labels: ${issue.labels?.join(", ") || "none"}${reposLine}${accessBlock}${treeBlock}${rulesBlock}${previousBlock}${validationBlock}
 
 ## Relevant files (current state as of the proposed changes)
 ${filesBlock}

package/server/forge/core/prompts.test.js

@@ -0,0 +1,219 @@
+import { describe, it, expect } from "vitest";
+
+import {
+	classifyIssue,
+	buildIdentifyFilesPrompt,
+	buildProposeFixPrompt,
+	buildRefineOrAskPrompt,
+} from "./prompts.js";
+
+// ─── classifyIssue ───────────────────────────────────────────────────────────
+
+describe("classifyIssue", () => {
+	it("detects feat prefix in title", () => {
+		expect(classifyIssue({ title: "feat(mixes): Live Mixes section" })).toBe("feature");
+		expect(classifyIssue({ title: "feat: add new page" })).toBe("feature");
+	});
+
+	it("detects fix prefix in title", () => {
+		expect(classifyIssue({ title: "fix: broken auth flow" })).toBe("fix");
+		expect(classifyIssue({ title: "fix(auth): token refresh race" })).toBe("fix");
+	});
+
+	it("detects chore prefix", () => {
+		expect(classifyIssue({ title: "chore: bump dependencies" })).toBe("chore");
+	});
+
+	it("detects refactor prefix", () => {
+		expect(classifyIssue({ title: "refactor: extract auth service" })).toBe("refactor");
+	});
+
+	it("falls back to labels when no title prefix", () => {
+		expect(classifyIssue({ title: "Add mixes page", labels: ["feature"] })).toBe("feature");
+		expect(classifyIssue({ title: "Add mixes page", labels: ["enhancement"] })).toBe("feature");
+		expect(classifyIssue({ title: "Auth broken", labels: ["bug"] })).toBe("fix");
+	});
+
+	it("handles label objects with name field", () => {
+		expect(classifyIssue({ title: "Add page", labels: [{ name: "Feature" }] })).toBe("feature");
+	});
+
+	it("falls back to description heuristics", () => {
+		expect(classifyIssue({
+			title: "Live Mixes section",
+			description: "## Approach\nReuse existing infrastructure...",
+		})).toBe("feature");
+
+		expect(classifyIssue({
+			title: "Multi-track mashups",
+			description: "## Frontend changes\n- Generalize StemsEngine...",
+		})).toBe("feature");
+	});
+
+	it("defaults to fix when nothing matches", () => {
+		expect(classifyIssue({ title: "Something is wrong" })).toBe("fix");
+		expect(classifyIssue({ title: "Update thing", labels: [] })).toBe("fix");
+	});
+
+	it("handles missing/null fields gracefully", () => {
+		expect(classifyIssue({})).toBe("fix");
+		expect(classifyIssue({ title: null, labels: null })).toBe("fix");
+	});
+});
+
+// ─── buildIdentifyFilesPrompt ────────────────────────────────────────────────
+
+describe("buildIdentifyFilesPrompt", () => {
+	const repoTrees = [
+		{ repo: "group/web-app", files: ["src/App.tsx", "src/types.ts"] },
+	];
+
+	it("uses feature selection rules for feat issues", () => {
+		const issue = { iid: 25, title: "feat(mixes): Live Mixes section", labels: [] };
+		const prompt = buildIdentifyFilesPrompt(issue, repoTrees);
+
+		expect(prompt).toContain("feature implementation");
+		expect(prompt).toContain("PATTERNS");
+		expect(prompt).toContain("max 15");
+		expect(prompt).not.toContain("failing assertion");
+	});
+
+	it("uses bug-fix selection rules for fix issues", () => {
+		const issue = { iid: 10, title: "fix: broken auth", labels: [] };
+		const prompt = buildIdentifyFilesPrompt(issue, repoTrees);
+
+		expect(prompt).toContain("bug fix");
+		expect(prompt).toContain("failing assertion");
+		expect(prompt).toContain("max 10");
+		expect(prompt).not.toContain("PATTERNS");
+	});
+
+	it("says implementing for features, fixing for bugs", () => {
+		const feat = buildIdentifyFilesPrompt(
+			{ iid: 1, title: "feat: new page", labels: [] }, repoTrees,
+		);
+		const fix = buildIdentifyFilesPrompt(
+			{ iid: 2, title: "fix: crash", labels: [] }, repoTrees,
+		);
+
+		expect(feat).toContain("implementing");
+		expect(fix).toContain("fixing");
+	});
+
+	it("includes multi-repo guidance when multiple repos present", () => {
+		const multi = [
+			{ repo: "group/web-app", files: ["src/App.tsx"] },
+			{ repo: "group/api", files: ["internal/handler.go"] },
+		];
+		const prompt = buildIdentifyFilesPrompt(
+			{ iid: 1, title: "fix: thing", labels: [] }, multi,
+		);
+		expect(prompt).toContain("Multi-repo guidance");
+		expect(prompt).toContain("group/web-app, group/api");
+	});
+});
+
+// ─── buildProposeFixPrompt ───────────────────────────────────────────────────
+
+describe("buildProposeFixPrompt", () => {
+	const fileContents = [
+		{ repo: "group/web-app", path: "src/App.tsx", content: "export default function App() {}" },
+	];
+
+	it("uses feat: prefix for feature issues", () => {
+		const issue = { iid: 25, title: "feat: add mixes", labels: [] };
+		const prompt = buildProposeFixPrompt(issue, fileContents);
+
+		expect(prompt).toContain('"feat:');
+		expect(prompt).toContain("Implement this feature");
+		expect(prompt).not.toContain("Root-cause discipline");
+	});
+
+	it("uses fix: prefix for bug issues", () => {
+		const issue = { iid: 10, title: "fix: broken auth", labels: [] };
+		const prompt = buildProposeFixPrompt(issue, fileContents);
+
+		expect(prompt).toContain('"fix:');
+		expect(prompt).toContain("Propose a targeted fix");
+		expect(prompt).toContain("Root-cause discipline");
+	});
+
+	it("includes feature discipline for feature issues", () => {
+		const issue = { iid: 25, title: "feat: mixes", labels: [] };
+		const prompt = buildProposeFixPrompt(issue, fileContents);
+
+		expect(prompt).toContain("Feature implementation rules");
+		expect(prompt).toContain("Follow the issue specification");
+		expect(prompt).toContain("Do NOT invent changes");
+	});
+
+	it("injects promptRules when provided", () => {
+		const issue = { iid: 1, title: "fix: thing", labels: [] };
+		const prompt = buildProposeFixPrompt(issue, fileContents, {
+			promptRules: "Never restructure the NavBar",
+		});
+
+		expect(prompt).toContain("Custom rules");
+		expect(prompt).toContain("Never restructure the NavBar");
+	});
+
+	it("omits promptRules block when empty", () => {
+		const issue = { iid: 1, title: "fix: thing", labels: [] };
+		const prompt = buildProposeFixPrompt(issue, fileContents, { promptRules: "" });
+
+		expect(prompt).not.toContain("Custom rules");
+	});
+
+	it("includes CI context when provided", () => {
+		const issue = { iid: 1, title: "fix: thing", labels: [] };
+		const prompt = buildProposeFixPrompt(issue, fileContents, {
+			ciContext: "Error: Cannot find module './missing'",
+		});
+
+		expect(prompt).toContain("CI pipeline failure logs");
+		expect(prompt).toContain("Cannot find module");
+	});
+});
+
+// ─── buildRefineOrAskPrompt ─────────────────────────────────────────────────
+
+describe("buildRefineOrAskPrompt", () => {
+	const issue = { iid: 1, title: "fix: thing", labels: [] };
+	const fileContents = [
+		{ repo: "r", path: "src/a.ts", content: "const x = 1;" },
+	];
+
+	it("injects promptRules", () => {
+		const prompt = buildRefineOrAskPrompt(issue, fileContents, {
+			feedback: "fix the types",
+			promptRules: "Always use strict TypeScript",
+		});
+
+		expect(prompt).toContain("Custom rules");
+		expect(prompt).toContain("Always use strict TypeScript");
+	});
+
+	it("omits promptRules when empty", () => {
+		const prompt = buildRefineOrAskPrompt(issue, fileContents, {
+			feedback: "fix it",
+			promptRules: "",
+		});
+		expect(prompt).not.toContain("Custom rules");
+	});
+
+	it("includes repo access block for tools mode", () => {
+		const prompt = buildRefineOrAskPrompt(issue, fileContents, {
+			feedback: "check types",
+			repoAccessMode: "tools",
+		});
+		expect(prompt).toContain("current working directory is a checkout");
+	});
+
+	it("includes repo access block for tree mode", () => {
+		const prompt = buildRefineOrAskPrompt(issue, fileContents, {
+			feedback: "check types",
+			repoAccessMode: "tree",
+		});
+		expect(prompt).toContain("full file tree above");
+	});
+});

package/server/forge/core/providers/azuredevops.js

@@ -247,13 +247,14 @@ export class AzureDevOpsProvider extends ScmProvider {
 
 	// ─── Repository ───────────────────────────────────────────────────────────
 
-	async getFileTree(srcPath = "src", ref = this._defaultBranch) {
+	async getFileTree(srcPath = "", ref = this._defaultBranch) {
+		const scopeParam = srcPath ? `&$scopePath=/${srcPath}` : "";
 		const data = await this._req(
-			`${this._gitBase()}/trees/${ref}?recursive=true&$scopePath=/${srcPath}`,
+			`${this._gitBase()}/trees/${ref}?recursive=true${scopeParam}`,
 		);
 		return (data?.treeEntries ?? [])
 			.filter((item) => item.gitObjectType === "blob")
-			.filter((item) => /\.(ts|tsx|js|jsx|json|css|yaml|yml|md)$/.test(item.relativePath))
+			.filter((item) => /\.(ts|tsx|js|jsx|json|css|yaml|yml|md|go|py|rs|java|rb|sh|toml)$/.test(item.relativePath))
 			.map((item) => item.relativePath);
 	}
 

package/server/forge/core/providers/github.js

@@ -186,13 +186,12 @@ export class GitHubProvider extends ScmProvider {
 
 	// ─── Repository ───────────────────────────────────────────────────────────
 
-	async getFileTree(srcPath = "src", ref = this._defaultBranch) {
-		// Use recursive tree API — much faster than walking
+	async getFileTree(srcPath = "", ref = this._defaultBranch) {
 		const data = await this._req(`/git/trees/${ref}?recursive=1`);
 		return (data.tree ?? [])
 			.filter((item) => item.type === "blob")
-			.filter((item) => item.path.startsWith(srcPath + "/") || item.path === srcPath)
-			.filter((item) => /\.(ts|tsx|js|jsx|json|css|yaml|yml|md)$/.test(item.path))
+			.filter((item) => !srcPath || item.path.startsWith(srcPath + "/") || item.path === srcPath)
+			.filter((item) => /\.(ts|tsx|js|jsx|json|css|yaml|yml|md|go|py|rs|java|rb|sh|toml)$/.test(item.path))
 			.map((item) => item.path);
 	}
 

package/server/forge/core/providers/gitlab.js

@@ -3,12 +3,12 @@
  *
  * GitLab REST API v4 implementation of ScmProvider.
  *
- * Required env vars:
- *   GITLAB_TOKEN          — personal access token
- *   FORGE_GITLAB_PROJECT  — default project path, e.g. "ipul/web-app"
+ * Token resolved via configStore.getConnection("gitlab") — set in Settings UI
+ * or via GITLAB_TOKEN env var. Project resolved via configStore.getPrimaryProject()
+ * or the constructor argument.
  */
 
-import { getConnection } from "../configStore.js";
+import { getConnection, getPrimaryProject } from "../configStore.js";
 import { ScmProvider } from "./base.js";
 
 const CLOSING_ISSUE_RE = /\b(?:Closes|Fixes|Resolves)\s+#(\d+)/gi;
@@ -24,7 +24,7 @@ export class GitLabProvider extends ScmProvider {
 	/** @param {string} [project] */
 	constructor(project) {
 		super();
-		this._project = project ?? process.env.FORGE_GITLAB_PROJECT;
+		this._project = project ?? getPrimaryProject();
 	}
 
 	get name() { return "gitlab"; }
@@ -173,7 +173,7 @@ export class GitLabProvider extends ScmProvider {
 
 	// ─── Repository ───────────────────────────────────────────────────────────
 
-	async getFileTree(srcPath = "src", ref = "main") {
+	async getFileTree(srcPath = "", ref = "main") {
 		const scan = async (pathParam) => {
 			const items = [];
 			let page = 1;

package/server/forge/core/validator/clone.js

@@ -14,6 +14,7 @@ import fs from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
 
+import { getConnection } from "../configStore.js";
 import { runCmd } from "./cmd.js";
 import { exists } from "./fs.js";
 
@@ -25,9 +26,9 @@ function sanitizeRepo(repo) {
 }
 
 function gitlabCloneUrl(project) {
-	const token = process.env.GITLAB_TOKEN;
+	const { token } = getConnection("gitlab");
 	if (!token) {
-		throw new Error("GITLAB_TOKEN is required to clone the repo for validation.");
+		throw new Error("GitLab token is required to clone the repo for validation. Set it in Settings → Connections or via GITLAB_TOKEN env var.");
 	}
 	return `https://oauth2:${token}@gitlab.com/${project}.git`;
 }

package/server/forge/core/validator.js

@@ -26,6 +26,7 @@
  */
 
 import { branchNameFor } from "./branchName.js";
+import * as configStore from "./configStore.js";
 import { attributeChanges } from "./validator/attribute.js";
 import { ensureClone } from "./validator/clone.js";
 import { overlayChanges } from "./validator/overlay.js";
@@ -86,8 +87,8 @@ function resolveCandidates(analysis) {
 	if (fromAnalysis.length) return fromAnalysis;
 	const fromChange = analysis.changes?.[0]?.repo;
 	if (fromChange) return [fromChange];
-	const env = process.env.FORGE_GITLAB_PROJECT;
-	return env ? [env] : [];
+	const primary = configStore.getPrimaryProject();
+	return primary ? [primary] : [];
 }
 
 /**

package/server/forge/routes.js

@@ -4,9 +4,9 @@
  * Express router for /api/forge/*.
  *
  * Required env vars:
- *   FORGE_TOKEN           — dashboard password
- *   FORGE_GITLAB_PROJECT  — GitLab project path, e.g. "ipul/web-app"
- *   GITLAB_TOKEN          — GitLab personal access token
+ *   FORGE_TOKEN   — dashboard password
+ *
+ * Project + token resolved via configStore (Settings UI) with env-var fallbacks.
  *
  * Multi-repo support
  * ──────────────────
@@ -80,9 +80,9 @@ function getAvailableRepos() {
 function parseRepo(req) {
 	const repos = getAvailableRepos();
 	const requested = req.query.repo ?? req.body?.repo ?? null;
-	if (!requested) return repos[0]?.id ?? process.env.FORGE_GITLAB_PROJECT;
+	if (!requested) return repos[0]?.id ?? configStore.getPrimaryProject();
 	const match = repos.find((r) => r.id === requested);
-	return match?.id ?? repos[0]?.id ?? process.env.FORGE_GITLAB_PROJECT;
+	return match?.id ?? repos[0]?.id ?? configStore.getPrimaryProject();
 }
 
 /**
@@ -177,10 +177,10 @@ router.get("/status", requireAuth, async (_req, res) => {
 
 	res.json({
 		ok: true,
-		project: process.env.FORGE_GITLAB_PROJECT ?? null,
+		project: configStore.getPrimaryProject(),
 		repos,
 		supportsMultiRepo: repos.length > 1,
-		hasGitlabToken: Boolean(process.env.GITLAB_TOKEN),
+		hasGitlabToken: Boolean(configStore.getConnection("gitlab").token),
 		defaultModel: process.env.FORGE_MODEL ?? "claude-sonnet-4-6",
 		models,
 		agents,