gflows 1.0.4 → 1.1.0

package/AGENTS.md

@@ -9,7 +9,7 @@ gflows is a **local Git branching workflow CLI** (main + dev + typed short-lived
 3. **Do not finish empty branches** — if there are no commits beyond the merge target, finish exits `2`. Commit first.
 4. **Conflicts** — resolve files, then `gflows continue`. Or `gflows abort` / `gflows undo`.
 5. **Discover the API** — run `gflows schema` (JSON) or read this file + README.
-6. **MCP** — `gflows mcp` (stdio JSON-RPC) exposes status/doctor/list/start/sync/finish/schema tools.
+6. **MCP** — `gflows mcp` (stdio JSON-RPC) exposes status/doctor/info/list/start/sync/finish/schema tools.
 7. **Hub / viz** — bare `gflows` (TTY) opens an Ink fullscreen hub (`/` commands). Prompts use Clack. `gflows viz` prints the scrollback status panel.
 
 ## Exit codes
@@ -51,6 +51,9 @@ gflows doctor --json
 gflows continue
 gflows abort
 gflows undo
+
+# Repo shape / stacks
+gflows info --json
 ```
 
 ## Branch merge targets

package/CHANGELOG.md

@@ -7,6 +7,13 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [1.1.0] - 2026-07-25
+
+### Added
+
+- `gflows info` — describe repo layout (monolith vs monorepo), package versions, and detected frontend / fullstack / backend stacks (`--json` supported)
+- Hub `/info` read-only screen; MCP tool `gflows_info`
+
 ## [1.0.4] - 2026-07-25
 
 ### Fixed

package/README.md

@@ -231,6 +231,7 @@ Hub: `g` → select the action. Typed short form assumes `alias g=gflows`.
 | `gflows abort` | — |
 | `gflows undo` | — |
 | `gflows doctor` | — |
+| `gflows info` | — |
 
 
 
@@ -274,6 +275,7 @@ Bare `gflows` / `g` in a **TTY** opens the Ink hub (see [Way 1](#way-1--hub-reco
 | `status` `-t`                 | Current branch flow info                    |
 | `viz`                         | Scrollback visual map                       |
 | `doctor`                      | Health checks                               |
+| `info`                        | Layout, versions, frontend/backend stacks   |
 | `config`                      | `get` / `set` `.gflows.json`                |
 | `bump` `-U`                   | Version bump/rollback in package files      |
 | `continue` / `abort` / `undo` | Recovery                                    |
@@ -395,6 +397,7 @@ Rules of thumb:
 | `gflows finish feature -y -P` | `g -F -f -y -P` |
 | `gflows status --json` | `g -t --json` |
 | `gflows doctor --json` | — |
+| `gflows info --json` | — |
 
 **Exit codes:** `0` ok · `1` usage/validation · `2` git/system (conflict, dirty tree, empty finish, …)
 

package/llms.txt

@@ -14,7 +14,7 @@
 - `gflows viz`: scrollback status panel — lifecycle, branches, recommended next step
 - `gflows init` / `start` / `finish` / `sync` / `pr`
 - `gflows continue` / `undo` / `abort` — recovery after conflicts
-- `gflows doctor` / `config` / `status --json` / `mcp`
+- `gflows doctor` / `info` / `config` / `status --json` / `mcp`
 
 ## Package
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gflows",
-  "version": "1.0.4",
+  "version": "1.1.0",
   "author": "Ali AlNaghmoush (https://github.com/alialnaghmoush)",
   "repository": {
     "type": "git",

package/src/commands/bump.ts

@@ -5,47 +5,16 @@
  * @module commands/bump
  */
 
-import { existsSync, readdirSync, readFileSync, statSync, writeFileSync } from "node:fs";
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
 import { join, relative } from "node:path";
 import { EXIT_OK, EXIT_USER } from "../constants.js";
 import { InvalidVersionError } from "../errors.js";
 import { hint, success } from "../out.js";
+import { findPackageRoots, PACKAGE_JSON } from "../packages.js";
 import type { BumpDirection, BumpType, ParsedArgs } from "../types.js";
 
-const PACKAGE_JSON = "package.json";
 const JSR_JSON = "jsr.json";
 
-/** Directory names to skip when discovering package roots (monorepo). */
-const SKIP_DIRS = new Set(["node_modules", ".git"]);
-
-/**
- * Recursively finds all directories under `root` that contain a package.json.
- * Skips node_modules and .git.
- */
-function findPackageRoots(root: string): string[] {
-  const acc: string[] = [];
-  if (!existsSync(root) || !statSync(root, { throwIfNoEntry: false })?.isDirectory()) {
-    return acc;
-  }
-  if (existsSync(join(root, PACKAGE_JSON))) {
-    acc.push(root);
-  }
-  let entries: Array<{ isDirectory(): boolean; name: string }>;
-  try {
-    entries = readdirSync(root, { withFileTypes: true }) as Array<{
-      isDirectory(): boolean;
-      name: string;
-    }>;
-  } catch {
-    return acc;
-  }
-  for (const e of entries) {
-    if (!e.isDirectory() || SKIP_DIRS.has(e.name)) continue;
-    acc.push(...findPackageRoots(join(root, e.name)));
-  }
-  return acc;
-}
-
 /** Semver triplet. */
 interface Semver {
   major: number;

package/src/commands/completion.ts

@@ -20,6 +20,7 @@ const COMMANDS = [
   "list",
   "bump",
   "doctor",
+  "info",
   "config",
   "schema",
   "continue",
@@ -260,6 +261,8 @@ complete -c gflows -f -n "not __fish_seen_subcommand_from ${COMMANDS.join(" ")}"
   -a "list" -d "List branches by type"
 complete -c gflows -f -n "not __fish_seen_subcommand_from ${COMMANDS.join(" ")}" \\
   -a "bump" -d "Bump or rollback version"
+complete -c gflows -f -n "not __fish_seen_subcommand_from ${COMMANDS.join(" ")}" \\
+  -a "info" -d "Repo layout, versions, and stacks"
 complete -c gflows -f -n "not __fish_seen_subcommand_from ${COMMANDS.join(" ")}" \\
   -a "completion" -d "Print shell completion script"
 complete -c gflows -f -n "not __fish_seen_subcommand_from ${COMMANDS.join(" ")}" \\

package/src/commands/help.ts

@@ -27,6 +27,7 @@ Commands:
   status, -t     Show current branch flow info
   viz            Visual branch map + flow (also shown in interactive hub)
   doctor         Repo health checks
+  info           Repo layout, versions, and stacks
   config         get/set .gflows.json
   bump, -U       Bump or rollback package version
   continue       Resume after merge conflict
@@ -53,7 +54,7 @@ Common flags:
   -v, --verbose        Verbose output
   -q, --quiet          Minimal output
   -C, --path <dir>     Run as if in <dir>
-  --json               Machine-readable output (status/list/doctor/config)
+  --json               Machine-readable output (status/list/doctor/info/config)
 
 Init:   --script-alias <name>  Add package.json script (e.g. g → "gflows")
         --no-script-alias      Never add a script alias

package/src/commands/info.ts

@@ -0,0 +1,33 @@
+/**
+ * Info: describe repo layout, package versions, and detected stacks.
+ * @module commands/info
+ */
+
+import { resolveRepoRoot } from "../git.js";
+import { collectInfoReport, formatInfoReport } from "../repo-inspect.js";
+import type { ParsedArgs } from "../types.js";
+
+/**
+ * Collects repo info without printing (CLI + hub).
+ */
+export async function collectInfo(cwd: string) {
+  const repoRoot = await resolveRepoRoot(cwd);
+  return collectInfoReport(repoRoot);
+}
+
+/**
+ * Runs the info command (human or JSON).
+ */
+export async function run(args: ParsedArgs): Promise<void> {
+  const report = await collectInfo(args.cwd);
+
+  if (args.json) {
+    console.log(JSON.stringify(report, null, 2));
+    return;
+  }
+
+  const lines = formatInfoReport(report);
+  for (const line of lines) {
+    console.log(line);
+  }
+}

package/src/commands/mcp.ts

@@ -31,6 +31,14 @@ const TOOLS = [
       properties: { path: { type: "string" } },
     },
   },
+  {
+    name: "gflows_info",
+    description: "Describe repo layout (monolith/monorepo), package versions, and stacks.",
+    inputSchema: {
+      type: "object",
+      properties: { path: { type: "string" } },
+    },
+  },
   {
     name: "gflows_list",
     description: "List workflow branches.",
@@ -123,6 +131,9 @@ async function runTool(
     case "gflows_doctor":
       argv.push("doctor", "--json");
       break;
+    case "gflows_info":
+      argv.push("info", "--json");
+      break;
     case "gflows_list":
       argv.push("list", "-q");
       if (typeof args.type === "string") argv.push(args.type);
@@ -174,7 +185,7 @@ async function runTool(
  */
 export async function run(_args: ParsedArgs): Promise<void> {
   console.error(
-    "gflows mcp: listening on stdio (JSON-RPC). Tools: status, doctor, list, start, sync, finish, schema.",
+    "gflows mcp: listening on stdio (JSON-RPC). Tools: status, doctor, info, list, start, sync, finish, schema.",
   );
 
   const decoder = new TextDecoder();

package/src/commands/schema.ts

@@ -60,6 +60,8 @@ export async function run(_args: ParsedArgs): Promise<void> {
       sync: ["--rebase", "--force"],
       list: ["-r/--include-remote", "--json"],
       status: ["--json"],
+      info: ["--json"],
+      doctor: ["--json"],
     },
     agentNotes: [
       "Always pass explicit flags in non-TTY (never assume interactive hub).",
@@ -84,6 +86,7 @@ function commandMeta(command: string): { summary: string; interactiveOk: boolean
     pr: { summary: "Open PR/MR via gh/glab", interactiveOk: true },
     viz: { summary: "Visual branch map and flow diagram", interactiveOk: true },
     doctor: { summary: "Repo health checks", interactiveOk: false },
+    info: { summary: "Repo layout, versions, and stacks", interactiveOk: false },
     config: { summary: "Get/set .gflows.json", interactiveOk: true },
     schema: { summary: "Machine-readable command catalog", interactiveOk: false },
     continue: { summary: "Resume suspended operation", interactiveOk: false },

package/src/interactive.ts

@@ -86,6 +86,7 @@ function buildLegacyOptions(
     { value: "list", label: "List branches" },
     { value: "viz", label: "Refresh map" },
     { value: "doctor", label: "Doctor (check setup)" },
+    { value: "info", label: "Info (layout & stacks)" },
     { value: "config", label: "Config" },
     { value: "bump", label: "Bump version" },
     { value: "continue", label: "Continue suspended operation" },

package/src/packages.ts

@@ -0,0 +1,78 @@
+/**
+ * Shared package.json discovery for monorepo-aware commands (bump, info).
+ * @module packages
+ */
+
+import { existsSync, readdirSync, readFileSync, statSync } from "node:fs";
+import { join } from "node:path";
+
+/** Filename for Node/Bun package manifests. */
+export const PACKAGE_JSON = "package.json";
+
+/** Directory names to skip when discovering package roots. */
+const SKIP_DIRS = new Set([
+  "node_modules",
+  ".git",
+  ".next",
+  ".nuxt",
+  ".turbo",
+  "dist",
+  "build",
+  "coverage",
+  ".cache",
+]);
+
+/**
+ * Recursively finds all directories under `root` that contain a package.json.
+ * Skips node_modules, .git, and common build/cache dirs.
+ */
+export function findPackageRoots(root: string): string[] {
+  const acc: string[] = [];
+  if (!existsSync(root) || !statSync(root, { throwIfNoEntry: false })?.isDirectory()) {
+    return acc;
+  }
+  if (existsSync(join(root, PACKAGE_JSON))) {
+    acc.push(root);
+  }
+  let entries: Array<{ isDirectory(): boolean; name: string }>;
+  try {
+    entries = readdirSync(root, { withFileTypes: true }) as Array<{
+      isDirectory(): boolean;
+      name: string;
+    }>;
+  } catch {
+    return acc;
+  }
+  for (const e of entries) {
+    if (!e.isDirectory() || SKIP_DIRS.has(e.name)) continue;
+    if (e.name.startsWith(".") && e.name !== ".") continue;
+    acc.push(...findPackageRoots(join(root, e.name)));
+  }
+  return acc;
+}
+
+/** Minimal package.json fields used by inspectors. */
+export interface PackageJsonFields {
+  name?: string;
+  version?: string;
+  description?: string;
+  private?: boolean;
+  workspaces?: string[] | { packages?: string[] };
+  dependencies?: Record<string, string>;
+  devDependencies?: Record<string, string>;
+  peerDependencies?: Record<string, string>;
+}
+
+/**
+ * Reads and parses package.json from a directory. Returns null if missing or invalid.
+ */
+export function readPackageJson(dir: string): PackageJsonFields | null {
+  const path = join(dir, PACKAGE_JSON);
+  if (!existsSync(path)) return null;
+  try {
+    const raw = readFileSync(path, "utf-8");
+    return JSON.parse(raw) as PackageJsonFields;
+  } catch {
+    return null;
+  }
+}

package/src/repo-inspect.ts

@@ -0,0 +1,465 @@
+/**
+ * Repo inspection for `gflows info`: layout, versions, and stack detection.
+ * @module repo-inspect
+ */
+
+import { existsSync, readdirSync, readFileSync } from "node:fs";
+import { join, relative } from "node:path";
+import { resolveConfig } from "./config.js";
+import { getCurrentBranch, runGit } from "./git.js";
+import { findPackageRoots, type PackageJsonFields, readPackageJson } from "./packages.js";
+
+/** Layout classification. */
+export type RepoLayout = "monolith" | "monorepo";
+
+/** One detected stack entry. */
+export interface StackHit {
+  id: string;
+  name: string;
+  packages: string[];
+}
+
+/** One package.json summary row. */
+export interface PackageVersionRow {
+  path: string;
+  name: string | null;
+  version: string | null;
+  private: boolean;
+}
+
+/** Structured report for CLI, hub, and tests. */
+export interface InfoReport {
+  root: string;
+  layout: RepoLayout;
+  layoutReasons: string[];
+  name: string | null;
+  version: string | null;
+  description: string | null;
+  packages: PackageVersionRow[];
+  stacks: {
+    frontend: StackHit[];
+    fullstack: StackHit[];
+    backend: StackHit[];
+  };
+  packageManager: string | null;
+  remoteUrl: string | null;
+  branch: string | null;
+  gflows: { main: string; dev: string; remote: string };
+  runtimes: string[];
+}
+
+type StackKind = "frontend" | "fullstack" | "backend";
+
+interface StackRule {
+  id: string;
+  name: string;
+  kind: StackKind;
+  keys: string[];
+  /** When set, all keys must be present (AND). Otherwise any key matches (OR). */
+  requireAll?: boolean;
+}
+
+const STACK_RULES: StackRule[] = [
+  // Frontend
+  { id: "react", name: "React", kind: "frontend", keys: ["react"] },
+  { id: "vue", name: "Vue", kind: "frontend", keys: ["vue"] },
+  { id: "angular", name: "Angular", kind: "frontend", keys: ["@angular/core"] },
+  { id: "svelte", name: "Svelte", kind: "frontend", keys: ["svelte"] },
+  { id: "solid", name: "Solid", kind: "frontend", keys: ["solid-js"] },
+  { id: "qwik", name: "Qwik", kind: "frontend", keys: ["@builder.io/qwik"] },
+  { id: "preact", name: "Preact", kind: "frontend", keys: ["preact"] },
+  { id: "alpine", name: "Alpine.js", kind: "frontend", keys: ["alpinejs"] },
+  { id: "lit", name: "Lit", kind: "frontend", keys: ["lit", "lit-element"] },
+  { id: "expo", name: "Expo", kind: "frontend", keys: ["expo"] },
+  { id: "react-native", name: "React Native", kind: "frontend", keys: ["react-native"] },
+  // Fullstack
+  { id: "next", name: "Next.js", kind: "fullstack", keys: ["next"] },
+  { id: "nuxt", name: "Nuxt", kind: "fullstack", keys: ["nuxt", "nuxt3"] },
+  { id: "sveltekit", name: "SvelteKit", kind: "fullstack", keys: ["@sveltejs/kit"] },
+  { id: "astro", name: "Astro", kind: "fullstack", keys: ["astro"] },
+  {
+    id: "remix",
+    name: "Remix",
+    kind: "fullstack",
+    keys: ["remix", "@remix-run/node", "@remix-run/react", "@remix-run/serve"],
+  },
+  {
+    id: "react-router",
+    name: "React Router (framework)",
+    kind: "fullstack",
+    keys: ["@react-router/node", "@react-router/dev", "@react-router/serve"],
+  },
+  {
+    id: "tanstack-start",
+    name: "TanStack Start",
+    kind: "fullstack",
+    keys: ["@tanstack/react-start", "@tanstack/solid-start"],
+  },
+  { id: "solidstart", name: "SolidStart", kind: "fullstack", keys: ["@solidjs/start"] },
+  {
+    id: "analog",
+    name: "Analog",
+    kind: "fullstack",
+    keys: ["@analogjs/platform", "@analogjs/vite-plugin-angular"],
+  },
+  {
+    id: "redwood",
+    name: "RedwoodJS",
+    kind: "fullstack",
+    keys: ["@redwoodjs/core", "@redwoodjs/api"],
+  },
+  { id: "blitz", name: "Blitz", kind: "fullstack", keys: ["blitz"] },
+  { id: "quasar", name: "Quasar", kind: "fullstack", keys: ["quasar"] },
+  { id: "gatsby", name: "Gatsby", kind: "fullstack", keys: ["gatsby"] },
+  // Backend
+  { id: "express", name: "Express", kind: "backend", keys: ["express"] },
+  { id: "nestjs", name: "NestJS", kind: "backend", keys: ["@nestjs/core"] },
+  { id: "fastify", name: "Fastify", kind: "backend", keys: ["fastify"] },
+  { id: "hono", name: "Hono", kind: "backend", keys: ["hono"] },
+  { id: "elysia", name: "Elysia", kind: "backend", keys: ["elysia"] },
+  { id: "koa", name: "Koa", kind: "backend", keys: ["koa"] },
+  { id: "oak", name: "Oak", kind: "backend", keys: ["@oak/oak", "oak"] },
+  { id: "hapi", name: "Hapi", kind: "backend", keys: ["@hapi/hapi"] },
+  { id: "restify", name: "Restify", kind: "backend", keys: ["restify"] },
+  { id: "trpc", name: "tRPC", kind: "backend", keys: ["@trpc/server"] },
+  { id: "nitro", name: "Nitro", kind: "backend", keys: ["nitropack", "nitro"] },
+  { id: "encore", name: "Encore.ts", kind: "backend", keys: ["encore.dev"] },
+  { id: "adonis", name: "AdonisJS", kind: "backend", keys: ["@adonisjs/core"] },
+  { id: "feathers", name: "Feathers", kind: "backend", keys: ["@feathersjs/feathers"] },
+  { id: "socketio", name: "Socket.IO", kind: "backend", keys: ["socket.io"] },
+];
+
+const WORKSPACE_MARKER_FILES = [
+  "pnpm-workspace.yaml",
+  "lerna.json",
+  "nx.json",
+  "turbo.json",
+  "rush.json",
+  "go.work",
+] as const;
+
+/**
+ * Collects direct dependency names from a package.json.
+ */
+function directDepNames(pkg: PackageJsonFields): Set<string> {
+  const names = new Set<string>();
+  for (const block of [pkg.dependencies, pkg.devDependencies, pkg.peerDependencies]) {
+    if (!block) continue;
+    for (const key of Object.keys(block)) names.add(key);
+  }
+  return names;
+}
+
+/**
+ * Detects package manager from lockfiles at repo root.
+ */
+function detectPackageManager(root: string): string | null {
+  if (existsSync(join(root, "bun.lockb")) || existsSync(join(root, "bun.lock"))) return "bun";
+  if (existsSync(join(root, "pnpm-lock.yaml"))) return "pnpm";
+  if (existsSync(join(root, "yarn.lock"))) return "yarn";
+  if (existsSync(join(root, "package-lock.json"))) return "npm";
+  return null;
+}
+
+/**
+ * Detects monorepo vs monolith and returns reasons.
+ */
+function detectLayout(
+  root: string,
+  rootPkg: PackageJsonFields | null,
+  packageRoots: string[],
+): { layout: RepoLayout; reasons: string[] } {
+  const reasons: string[] = [];
+
+  if (rootPkg?.workspaces !== undefined) {
+    reasons.push("package.json workspaces");
+  }
+  for (const file of WORKSPACE_MARKER_FILES) {
+    if (existsSync(join(root, file))) {
+      reasons.push(file);
+    }
+  }
+  if (existsSync(join(root, "Cargo.toml"))) {
+    try {
+      const cargo = readFileSync(join(root, "Cargo.toml"), "utf-8");
+      if (/\[workspace\]/.test(cargo)) reasons.push("Cargo.toml [workspace]");
+    } catch {
+      /* ignore */
+    }
+  }
+  if (packageRoots.length > 1) {
+    reasons.push(`${packageRoots.length} package.json files`);
+  }
+
+  if (reasons.length > 0) {
+    return { layout: "monorepo", reasons };
+  }
+  return { layout: "monolith", reasons: ["single package root"] };
+}
+
+/**
+ * Matches stack rules against direct deps of one package.
+ */
+function matchStacks(
+  depNames: Set<string>,
+  packageLabel: string,
+  acc: Map<string, StackHit>,
+): void {
+  for (const rule of STACK_RULES) {
+    const hit = rule.requireAll
+      ? rule.keys.every((k) => depNames.has(k))
+      : rule.keys.some((k) => depNames.has(k));
+    if (!hit) continue;
+    const existing = acc.get(rule.id);
+    if (existing) {
+      if (!existing.packages.includes(packageLabel)) {
+        existing.packages.push(packageLabel);
+      }
+    } else {
+      acc.set(rule.id, {
+        id: rule.id,
+        name: rule.name,
+        packages: [packageLabel],
+      });
+    }
+  }
+}
+
+/**
+ * When NestJS is present, drop Express/Fastify if they only appear as Nest platforms.
+ */
+function suppressNestPlatformNoise(hits: Map<string, StackHit>): void {
+  if (!hits.has("nestjs")) return;
+  for (const id of ["express", "fastify"] as const) {
+    const nest = hits.get("nestjs");
+    const platform = hits.get(id);
+    if (!nest || !platform) continue;
+    const onlyNestPkgs = platform.packages.every((p) => nest.packages.includes(p));
+    if (onlyNestPkgs) hits.delete(id);
+  }
+}
+
+/**
+ * Detects non-JS runtimes / frameworks from root manifests.
+ */
+function detectNonJsRuntimes(root: string): string[] {
+  const out: string[] = [];
+  if (existsSync(join(root, "go.mod"))) out.push("Go");
+  if (existsSync(join(root, "Cargo.toml"))) out.push("Rust");
+  if (
+    existsSync(join(root, "pyproject.toml")) ||
+    existsSync(join(root, "requirements.txt")) ||
+    existsSync(join(root, "Pipfile"))
+  ) {
+    out.push("Python");
+    for (const file of ["pyproject.toml", "requirements.txt", "Pipfile"] as const) {
+      const path = join(root, file);
+      if (!existsSync(path)) continue;
+      try {
+        const text = readFileSync(path, "utf-8").toLowerCase();
+        if (text.includes("django")) out.push("Django");
+        if (text.includes("flask")) out.push("Flask");
+        if (text.includes("fastapi")) out.push("FastAPI");
+      } catch {
+        /* ignore */
+      }
+    }
+  }
+  if (existsSync(join(root, "Gemfile"))) {
+    out.push("Ruby");
+    try {
+      const gem = readFileSync(join(root, "Gemfile"), "utf-8").toLowerCase();
+      if (/\brails\b/.test(gem)) out.push("Rails");
+    } catch {
+      /* ignore */
+    }
+  }
+  if (existsSync(join(root, "composer.json"))) {
+    out.push("PHP");
+    try {
+      const composer = readFileSync(join(root, "composer.json"), "utf-8");
+      if (composer.includes("laravel/framework")) out.push("Laravel");
+    } catch {
+      /* ignore */
+    }
+  }
+  if (hasFileWithExt(root, ".csproj") || hasFileWithExt(root, ".sln")) {
+    out.push(".NET");
+  }
+  if (
+    existsSync(join(root, "pom.xml")) ||
+    existsSync(join(root, "build.gradle")) ||
+    existsSync(join(root, "build.gradle.kts"))
+  ) {
+    out.push("JVM");
+  }
+  return [...new Set(out)];
+}
+
+/**
+ * Returns true if any file in `dir` (non-recursive) ends with `ext`.
+ */
+function hasFileWithExt(dir: string, ext: string): boolean {
+  try {
+    const entries = readdirSync(dir);
+    return entries.some((name) => name.endsWith(ext));
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Formats package path relative to root (`.` for root).
+ */
+function packageLabel(root: string, dir: string): string {
+  const rel = relative(root, dir);
+  return rel === "" ? "." : rel;
+}
+
+/**
+ * Collects a full info report for a git/repo root directory.
+ */
+export async function collectInfoReport(repoRoot: string): Promise<InfoReport> {
+  const rootPkg = readPackageJson(repoRoot);
+  let packageRoots = findPackageRoots(repoRoot);
+  packageRoots = [...packageRoots].sort((a, b) => {
+    if (a === repoRoot && b !== repoRoot) return -1;
+    if (a !== repoRoot && b === repoRoot) return 1;
+    return a.localeCompare(b);
+  });
+
+  const { layout, reasons } = detectLayout(repoRoot, rootPkg, packageRoots);
+
+  const packages: PackageVersionRow[] = [];
+  const stackAcc = new Map<string, StackHit>();
+  const kindById = new Map(STACK_RULES.map((r) => [r.id, r.kind]));
+
+  for (const dir of packageRoots) {
+    const pkg = readPackageJson(dir);
+    const label = packageLabel(repoRoot, dir);
+    packages.push({
+      path: label,
+      name: typeof pkg?.name === "string" ? pkg.name : null,
+      version: typeof pkg?.version === "string" ? pkg.version : null,
+      private: pkg?.private === true,
+    });
+    if (pkg) {
+      matchStacks(directDepNames(pkg), label, stackAcc);
+    }
+  }
+
+  suppressNestPlatformNoise(stackAcc);
+
+  const frontend: StackHit[] = [];
+  const fullstack: StackHit[] = [];
+  const backend: StackHit[] = [];
+  for (const hit of stackAcc.values()) {
+    const kind = kindById.get(hit.id);
+    if (kind === "frontend") frontend.push(hit);
+    else if (kind === "fullstack") fullstack.push(hit);
+    else if (kind === "backend") backend.push(hit);
+  }
+  const byName = (a: StackHit, b: StackHit) => a.name.localeCompare(b.name);
+  frontend.sort(byName);
+  fullstack.sort(byName);
+  backend.sort(byName);
+
+  const gflows = resolveConfig(repoRoot, {}, {});
+  let remoteUrl: string | null = null;
+  try {
+    const remoteResult = await runGit(["remote", "get-url", gflows.remote], {
+      cwd: repoRoot,
+      verbose: false,
+    });
+    const url = remoteResult.stdout.trim();
+    if (url) remoteUrl = url;
+  } catch {
+    remoteUrl = null;
+  }
+
+  let branch: string | null = null;
+  try {
+    branch = await getCurrentBranch(repoRoot, { verbose: false });
+  } catch {
+    branch = null;
+  }
+
+  return {
+    root: repoRoot,
+    layout,
+    layoutReasons: reasons,
+    name: typeof rootPkg?.name === "string" ? rootPkg.name : null,
+    version: typeof rootPkg?.version === "string" ? rootPkg.version : null,
+    description: typeof rootPkg?.description === "string" ? rootPkg.description : null,
+    packages,
+    stacks: { frontend, fullstack, backend },
+    packageManager: detectPackageManager(repoRoot),
+    remoteUrl,
+    branch,
+    gflows: { main: gflows.main, dev: gflows.dev, remote: gflows.remote },
+    runtimes: detectNonJsRuntimes(repoRoot),
+  };
+}
+
+/**
+ * Formats an InfoReport as human-readable lines.
+ */
+export function formatInfoReport(report: InfoReport): string[] {
+  const lines: string[] = [];
+  const title = report.name ?? (relative(process.cwd(), report.root) || report.root);
+  lines.push(`Repo: ${title}  (${report.layout})`);
+  if (report.version) {
+    lines.push(`Version: ${report.version} (root)`);
+  } else if (report.packages.length === 0) {
+    lines.push("Version: (no package.json)");
+  } else {
+    lines.push("Version: (none at root)");
+  }
+  if (report.description) {
+    lines.push(`Description: ${report.description}`);
+  }
+
+  const nested = report.packages.filter((p) => p.path !== ".");
+  if (nested.length > 0) {
+    lines.push("Packages:");
+    for (const p of nested) {
+      const ver = p.version ?? "—";
+      const nm = p.name ? ` ${p.name}` : "";
+      lines.push(`  ${p.path.padEnd(24)} ${ver}${nm}`);
+    }
+  }
+
+  const fmt = (hits: StackHit[]) => hits.map((h) => h.name).join(", ");
+  if (report.stacks.frontend.length > 0) {
+    lines.push(`Frontend:  ${fmt(report.stacks.frontend)}`);
+  }
+  if (report.stacks.fullstack.length > 0) {
+    lines.push(`Fullstack: ${fmt(report.stacks.fullstack)}`);
+  }
+  if (report.stacks.backend.length > 0) {
+    lines.push(`Backend:   ${fmt(report.stacks.backend)}`);
+  }
+  if (
+    report.stacks.frontend.length === 0 &&
+    report.stacks.fullstack.length === 0 &&
+    report.stacks.backend.length === 0 &&
+    report.runtimes.length === 0
+  ) {
+    lines.push("Stacks:    (none detected)");
+  }
+  if (report.runtimes.length > 0) {
+    lines.push(`Runtimes:  ${report.runtimes.join(", ")}`);
+  }
+
+  const meta: string[] = [];
+  if (report.packageManager) meta.push(report.packageManager);
+  meta.push(`${report.gflows.main}/${report.gflows.dev}`);
+  if (report.branch) meta.push(`branch ${report.branch}`);
+  if (meta.length > 0) {
+    lines.push(`PM: ${meta.join(" · ")}`);
+  }
+  if (report.remoteUrl) {
+    lines.push(`Remote: ${report.remoteUrl}`);
+  }
+  return lines;
+}

package/src/tui/HubHome.tsx

@@ -289,7 +289,7 @@ export function HubHome({
           ) : (
             <Text color={MUTED}>
               {showHelp
-                ? "/init /start /sync /pr /finish /doctor /help  ·  esc clear  ·  ctrl+c quit"
+                ? "/init /start /sync /pr /finish /doctor /info /help  ·  esc clear  ·  ctrl+c quit"
                 : "? for shortcuts · / for command menu"}
             </Text>
           )}
@@ -376,6 +376,7 @@ function buildActions(snap: VizSnapshot | null, recommended: RecommendAction | n
   push("switch", "Switch branch", "/switch");
   push("list", "List branches", "/list");
   push("doctor", "Doctor", "/doctor");
+  push("info", "Info", "/info");
   push("help", "Help", "/help");
   push("quit", "Quit", "q");
 

package/src/tui/HubShell.tsx

@@ -18,7 +18,7 @@ import {
 import { HubHome } from "./HubHome.js";
 import { WizardFrame } from "./prompts.js";
 import { SLASH_COMMANDS } from "./slash.js";
-import { ConfigView, DoctorView, HelpView, StatusView, VersionView } from "./views.js";
+import { ConfigView, DoctorView, HelpView, InfoView, StatusView, VersionView } from "./views.js";
 
 const ACCENT = "#E88C4A";
 const MUTED = "#8A8A8A";
@@ -37,6 +37,7 @@ type Screen =
   | { id: "init" }
   | { id: "bump" }
   | { id: "doctor" }
+  | { id: "info" }
   | { id: "help" }
   | { id: "status" }
   | { id: "config" }
@@ -104,6 +105,9 @@ export function HubShell({ cwd, onDone }: HubShellProps): React.ReactElement {
       case "doctor":
         setScreen({ id: "doctor" });
         return true;
+      case "info":
+        setScreen({ id: "info" });
+        return true;
       case "help":
         setScreen({ id: "help" });
         return true;
@@ -231,6 +235,9 @@ export function HubShell({ cwd, onDone }: HubShellProps): React.ReactElement {
   if (screen.id === "doctor") {
     return <DoctorView cwd={cwd} onDone={cancelWizard} />;
   }
+  if (screen.id === "info") {
+    return <InfoView cwd={cwd} onDone={cancelWizard} />;
+  }
   if (screen.id === "help") {
     return <HelpView onDone={cancelWizard} />;
   }

package/src/tui/slash.ts

@@ -24,6 +24,7 @@ export const SLASH_COMMANDS: readonly SlashCommand[] = [
   { name: "switch", hint: "Switch branch" },
   { name: "list", hint: "List branches" },
   { name: "doctor", hint: "Doctor checks" },
+  { name: "info", hint: "Repo layout & stacks" },
   { name: "help", hint: "Show help" },
   { name: "status", hint: "Repo status" },
   { name: "config", hint: "Show config" },

package/src/tui/views.tsx

@@ -1,5 +1,5 @@
 /**
- * Read-only Ink screens that stay inside the hub (doctor / help / status / config).
+ * Read-only Ink screens that stay inside the hub (doctor / info / help / status / config).
  * @module tui/views
  */
 
@@ -7,9 +7,11 @@ import type React from "react";
 import { useEffect, useState } from "react";
 import { collectDoctorReport } from "../commands/doctor.js";
 import { getHelpText } from "../commands/help.js";
+import { collectInfo } from "../commands/info.js";
 import { collectStatusLines } from "../commands/status-lines.js";
 import { resolveConfig } from "../config.js";
 import { resolveRepoRoot } from "../git.js";
+import { formatInfoReport } from "../repo-inspect.js";
 import { getVersion } from "../version.js";
 import { type HubPanelLine, HubScrollPanel } from "./panels.js";
 
@@ -60,6 +62,45 @@ export function DoctorView({
   return <HubScrollPanel title="Doctor" lines={lines} error={error} onDone={onDone} />;
 }
 
+/**
+ * Repo layout / versions / stacks inside the hub.
+ */
+export function InfoView({ cwd, onDone }: { cwd: string; onDone: () => void }): React.ReactElement {
+  const [lines, setLines] = useState<HubPanelLine[] | null>(null);
+  const [error, setError] = useState<string | null>(null);
+
+  useEffect(() => {
+    let cancelled = false;
+    void (async () => {
+      try {
+        const report = await collectInfo(cwd);
+        if (cancelled) return;
+        const rows: HubPanelLine[] = formatInfoReport(report).map((text, i) => ({
+          id: `i${i}`,
+          text: text.length === 0 ? " " : text,
+          tone:
+            text.startsWith("Repo:") ||
+            text.startsWith("Frontend:") ||
+            text.startsWith("Fullstack:")
+              ? "accent"
+              : "default",
+        }));
+        setLines(rows);
+      } catch (err) {
+        if (!cancelled) {
+          setError(err instanceof Error ? err.message : String(err));
+          setLines([]);
+        }
+      }
+    })();
+    return () => {
+      cancelled = true;
+    };
+  }, [cwd]);
+
+  return <HubScrollPanel title="Info" lines={lines} error={error} onDone={onDone} />;
+}
+
 /**
  * Scrollable help inside the hub.
  */

package/src/types.ts

@@ -38,6 +38,7 @@ export type Command =
   | "sync"
   | "pr"
   | "doctor"
+  | "info"
   | "config"
   | "schema"
   | "continue"
@@ -59,6 +60,7 @@ export const ALL_COMMANDS: Command[] = [
   "pr",
   "viz",
   "doctor",
+  "info",
   "config",
   "schema",
   "continue",