@fuzdev/fuz_gitops 0.76.0 → 0.78.0

package/dist/publishing_plan.js

@@ -1,4 +1,5 @@
 import { styleText as st } from 'node:util';
+import { repo_is_npm } from './local_repo.js';
 import { validate_dependency_graph } from './graph_validation.js';
 import { is_breaking_change, compare_bump_types, calculate_next_version, } from './version_utils.js';
 import { default_changeset_operations } from './operations_defaults.js';
@@ -11,12 +12,21 @@ export { log_publishing_plan } from './publishing_plan_logging.js';
  * Shows version changes, dependency updates, and breaking change cascades.
  * Uses fixed-point iteration to resolve transitive cascades.
  */
-export const generate_publishing_plan = async (repos, options = {}) => {
+export const generate_publishing_plan = async (all_repos, options = {}) => {
     const { log, ops = default_changeset_operations, verbose } = options;
     log?.info(st('cyan', 'Generating publishing plan...'));
     const warnings = [];
     const info = []; // Informational status (not warnings)
     const errors = [];
+    // Publishing concerns only npm packages. Non-npm repos (e.g. Rust cargo repos) are
+    // loaded for the dashboard but have no npm identity in the changeset cascade — drop them
+    // before building the graph so they never appear in the plan or publishing order.
+    const non_npm_repos = all_repos.filter((r) => !repo_is_npm(r));
+    if (non_npm_repos.length > 0) {
+        info.push(`Excluded ${non_npm_repos.length} non-npm repo(s) from publishing: ` +
+            non_npm_repos.map((r) => r.library.name).join(', '));
+    }
+    const repos = all_repos.filter(repo_is_npm);
     // Verbose data collection
     const verbose_changeset_details = [];
     const verbose_iterations = [];

package/dist/publishing_plan_logging.d.ts

@@ -5,7 +5,7 @@
  *
  * @module
  */
-import type { Logger } from '@fuzdev/fuz_util/log.js';
+import type { Logger } from '@fuzdev/fuz_util/log.ts';
 import type { PublishingPlan } from './publishing_plan.js';
 export interface LogPlanOptions {
     verbose?: boolean;

package/dist/repo.svelte.d.ts

@@ -1,8 +1,8 @@
-import type { LibraryJson, SourceJson } from '@fuzdev/fuz_util/library_json.js';
-import type { PkgJson } from '@fuzdev/fuz_util/pkg_json.js';
-import type { PackageJson } from '@fuzdev/fuz_util/package_json.js';
-import type { Url } from '@fuzdev/fuz_util/url.js';
-import { Library } from '@fuzdev/fuz_ui/library.svelte.js';
+import type { LibraryJson, SourceJson } from '@fuzdev/fuz_util/library_json.ts';
+import type { PkgJson } from '@fuzdev/fuz_util/pkg_json.ts';
+import type { PackageJson } from '@fuzdev/fuz_util/package_json.ts';
+import type { Url } from '@fuzdev/fuz_util/url.ts';
+import { Library } from '@fuzdev/fuz_ui/library.svelte.ts';
 import { GithubCheckRunsItem, type GithubPullRequest } from './github.js';
 /**
  * Serialized repo data as stored in `repos.ts` (JSON).

package/dist/repo.svelte.js

@@ -1,5 +1,5 @@
-import { create_context } from '@fuzdev/fuz_ui/context_helpers.js';
-import { Library } from '@fuzdev/fuz_ui/library.svelte.js';
+import { create_context } from '@fuzdev/fuz_ui/context_helpers.ts';
+import { Library } from '@fuzdev/fuz_ui/library.svelte.ts';
 import { GithubCheckRunsItem } from './github.js';
 /**
  * Runtime repo with `Library` composition for package metadata.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fuzdev/fuz_gitops",
-  "version": "0.76.0",
+  "version": "0.78.0",
   "description": "a tool for managing many repos",
   "glyph": "🪄",
   "logo": "logo.svg",
@@ -30,8 +30,8 @@
   },
   "peerDependencies": {
     "@fuzdev/fuz_css": ">=0.62.0",
-    "@fuzdev/fuz_ui": ">=0.205.0",
-    "@fuzdev/fuz_util": ">=0.65.1",
+    "@fuzdev/fuz_ui": ">=0.205.1",
+    "@fuzdev/fuz_util": ">=0.65.2",
     "@fuzdev/gro": ">=0.204.0",
     "@sveltejs/kit": "^2",
     "svelte": "^5",
@@ -40,18 +40,18 @@
   "devDependencies": {
     "@changesets/changelog-git": "^0.2.1",
     "@fuzdev/blake3_wasm": "^0.1.1",
-    "@fuzdev/fuz_code": "^0.46.0",
-    "@fuzdev/fuz_css": "^0.63.0",
-    "@fuzdev/fuz_ui": "^0.205.0",
-    "@fuzdev/fuz_util": "^0.65.1",
-    "@fuzdev/gro": "^0.204.0",
+    "@fuzdev/fuz_code": "^0.46.1",
+    "@fuzdev/fuz_css": "^0.63.2",
+    "@fuzdev/fuz_ui": "^0.205.1",
+    "@fuzdev/fuz_util": "^0.65.2",
+    "@fuzdev/gro": "^0.205.1",
     "@fuzdev/mdz": "^0.1.0",
     "@ryanatkn/eslint-config": "^0.12.1",
     "@sveltejs/acorn-typescript": "^1.0.9",
     "@sveltejs/adapter-static": "^3.0.10",
     "@sveltejs/kit": "^2.63.0",
     "@sveltejs/package": "^2.5.7",
-    "@sveltejs/vite-plugin-svelte": "^6.2.4",
+    "@sveltejs/vite-plugin-svelte": "^7.1.2",
     "@types/estree": "^1.0.8",
     "@types/node": "^24.10.1",
     "@webref/css": "^8.2.0",
@@ -68,7 +68,7 @@
     "tslib": "^2.8.1",
     "typescript": "^5.9.3",
     "typescript-eslint": "^8.48.1",
-    "vite": "^7.3.1",
+    "vite": "^8.0.16",
     "vitest": "^4.0.15",
     "zimmerframe": "^1.1.4",
     "zod": "^4.3.6"

package/src/lib/cargo_toml.ts

@@ -0,0 +1,82 @@
+import {existsSync} from 'node:fs';
+import {readFile} from 'node:fs/promises';
+import {join} from 'node:path';
+
+/**
+ * The handful of identity fields gitops reads from a Rust repo's `Cargo.toml`
+ * to render it on the dashboard. Everything is optional — a workspace root has
+ * no `name`, and any field may be absent or inherited.
+ */
+export interface CargoMetadata {
+	name?: string;
+	version?: string;
+	description?: string;
+	repository?: string;
+}
+
+/** The `Cargo.toml` tables that carry package identity (single-crate vs workspace root). */
+const CARGO_METADATA_SECTIONS: ReadonlySet<string> = new Set(['package', 'workspace.package']);
+const CARGO_METADATA_KEYS = ['name', 'version', 'description', 'repository'] as const;
+type CargoMetadataKey = (typeof CARGO_METADATA_KEYS)[number];
+
+/**
+ * Best-effort read of a repo's root `Cargo.toml` for the identity fields the
+ * gitops dashboard renders. Returns `null` when there's no `Cargo.toml`.
+ *
+ * @param repo_dir - absolute path to the repo
+ */
+export const cargo_toml_load = async (repo_dir: string): Promise<CargoMetadata | null> => {
+	const cargo_toml_path = join(repo_dir, 'Cargo.toml');
+	if (!existsSync(cargo_toml_path)) return null;
+	return cargo_toml_parse(await readFile(cargo_toml_path, 'utf8'));
+};
+
+/**
+ * Extracts `name`/`version`/`description`/`repository` from the `[package]` and
+ * `[workspace.package]` tables of a `Cargo.toml`.
+ *
+ * Deliberately not a full TOML parser: it scans for simple `key = "value"`
+ * string entries in those two tables, which covers both a single-crate manifest
+ * and a workspace root. Inline-table values like `version = { workspace = true }`
+ * (and the equivalent `version.workspace = true`) are ignored — a member crate
+ * inheriting from the workspace has no literal here, and gitops only ever reads a
+ * repo's root manifest, where these are concrete. The first non-empty value for a
+ * key wins, so a top-level `[package]` takes precedence over `[workspace.package]`
+ * when both appear.
+ */
+export const cargo_toml_parse = (contents: string): CargoMetadata => {
+	const metadata: CargoMetadata = {};
+	let in_metadata_section = false;
+	for (const raw_line of contents.split('\n')) {
+		const line = raw_line.trim();
+		if (line === '' || line.startsWith('#')) continue;
+		// Section header — only `[package]`/`[workspace.package]` arm value capture.
+		if (line.startsWith('[')) {
+			const end = line.indexOf(']');
+			in_metadata_section = end !== -1 && CARGO_METADATA_SECTIONS.has(line.slice(1, end).trim());
+			continue;
+		}
+		if (!in_metadata_section) continue;
+		const eq = line.indexOf('=');
+		if (eq === -1) continue;
+		const key = line.slice(0, eq).trim();
+		if (!CARGO_METADATA_KEYS.includes(key as CargoMetadataKey)) continue;
+		if (metadata[key as CargoMetadataKey] !== undefined) continue; // first value wins
+		const value = cargo_toml_string_value(line.slice(eq + 1).trim());
+		if (value !== null) metadata[key as CargoMetadataKey] = value;
+	}
+	return metadata;
+};
+
+/**
+ * Reads a simple single- or double-quoted TOML string, ignoring any trailing
+ * inline comment. Returns `null` for non-string values (inline tables, arrays,
+ * booleans, numbers), which the caller skips.
+ */
+const cargo_toml_string_value = (raw: string): string | null => {
+	const quote = raw[0];
+	if (quote !== '"' && quote !== "'") return null;
+	const end = raw.indexOf(quote, 1);
+	if (end === -1) return null;
+	return raw.slice(1, end);
+};

package/src/lib/changeset_generator.ts

@@ -8,16 +8,16 @@
  */
 
 import {join} from 'node:path';
-import type {Logger} from '@fuzdev/fuz_util/log.js';
-import type {LocalRepo} from './local_repo.js';
-import type {PublishedVersion} from './multi_repo_publisher.js';
+import type {Logger} from '@fuzdev/fuz_util/log.ts';
+import type {LocalRepo} from './local_repo.ts';
+import type {PublishedVersion} from './multi_repo_publisher.ts';
 import {
 	strip_version_prefix,
 	required_bump_for_dependency_update,
 	type BumpType,
-} from './version_utils.js';
-import type {FsOperations} from './operations.js';
-import {default_fs_operations} from './operations_defaults.js';
+} from './version_utils.ts';
+import type {FsOperations} from './operations.ts';
+import {default_fs_operations} from './operations_defaults.ts';
 
 export interface DependencyVersionChange {
 	package_name: string;

package/src/lib/changeset_reader.ts

@@ -7,13 +7,13 @@
  * @module
  */
 
-import type {Logger} from '@fuzdev/fuz_util/log.js';
+import type {Logger} from '@fuzdev/fuz_util/log.ts';
 import {existsSync} from 'node:fs';
 import {readdir, readFile} from 'node:fs/promises';
 import {join} from 'node:path';
 
-import type {LocalRepo} from './local_repo.js';
-import {compare_bump_types, calculate_next_version, type BumpType} from './version_utils.js';
+import type {LocalRepo} from './local_repo.ts';
+import {compare_bump_types, calculate_next_version, type BumpType} from './version_utils.ts';
 
 export interface ChangesetInfo {
 	filename: string;

package/src/lib/ci_reconcile.ts

@@ -0,0 +1,73 @@
+/**
+ * Reconciles each repo's declared `ci` flag against whether it actually has
+ * GitHub Actions workflow files on disk.
+ *
+ * The gitops config derives `ci` from visibility (on for public repos, off for
+ * private) with per-repo overrides; this check catches drift between that
+ * declaration and reality —
+ * a repo that claims CI but ships no workflow, or one that disclaims CI yet
+ * still carries one. Repos that aren't checked out locally can't be judged, so
+ * the caller marks them uncheckable and they're skipped. Archived repos are
+ * frozen on their host, so their CI state is intentionally left alone and they're
+ * skipped too.
+ *
+ * @module
+ */
+
+import {existsSync, readdirSync} from 'node:fs';
+import {join} from 'node:path';
+
+/** How a repo's declared `ci` diverges from its workflow files on disk. */
+export type CiDriftKind =
+	/** `ci` is `true` but the repo has no workflow files. */
+	| 'missing_ci'
+	/** `ci` is `false` but the repo has workflow files. */
+	| 'stray_ci';
+
+export interface CiDrift {
+	repo_url: string;
+	/** The declared/derived `ci` value. */
+	ci: boolean;
+	has_workflows: boolean;
+	kind: CiDriftKind;
+}
+
+export interface CiReconcileInput {
+	repo_url: string;
+	/** The declared/derived `ci` value from the gitops config. */
+	ci: boolean;
+	/** Whether the repo has at least one workflow file on disk. */
+	has_workflows: boolean;
+	/** Whether the repo is checked out locally; uncheckable repos are skipped. */
+	checkable: boolean;
+	/** Whether the repo is archived (frozen) on its host; archived repos are skipped. */
+	archived: boolean;
+}
+
+/**
+ * Compares each repo's declared `ci` against its actual workflow presence.
+ * @returns one `CiDrift` per repo whose declaration and reality disagree
+ */
+export const reconcile_ci = (repos: Array<CiReconcileInput>): Array<CiDrift> => {
+	const drift: Array<CiDrift> = [];
+	for (const repo of repos) {
+		if (!repo.checkable || repo.archived) continue;
+		const {repo_url, ci, has_workflows} = repo;
+		if (ci && !has_workflows) {
+			drift.push({repo_url, ci, has_workflows, kind: 'missing_ci'});
+		} else if (!ci && has_workflows) {
+			drift.push({repo_url, ci, has_workflows, kind: 'stray_ci'});
+		}
+	}
+	return drift;
+};
+
+/**
+ * Whether a local repo directory contains at least one GitHub Actions workflow.
+ * @param repo_dir - absolute or cwd-relative path to the repo's local directory
+ */
+export const repo_has_workflows = (repo_dir: string): boolean => {
+	const workflows_dir = join(repo_dir, '.github', 'workflows');
+	if (!existsSync(workflows_dir)) return false;
+	return readdirSync(workflows_dir).some((file) => file.endsWith('.yml') || file.endsWith('.yaml'));
+};

package/src/lib/config_reconcile.ts

@@ -0,0 +1,94 @@
+/**
+ * Reconciles repo metadata across multiple gitops configs.
+ *
+ * The ecosystem keeps several gitops configs — a canonical superset plus
+ * narrower per-project subsets. They can't share one source of truth (the
+ * superset includes private repos that public configs may not reference), so the
+ * same repo is declared independently in each. This check flags when a subset's
+ * intrinsic fields drift from the canonical config, or when a subset lists a
+ * repo the canonical config doesn't. `repo_dir` is per-config and ignored.
+ *
+ * @module
+ */
+
+import type {GitopsRepoConfig} from './gitops_config.ts';
+
+/** Repo fields that must agree across every config that lists the repo. */
+const INTRINSIC_FIELDS = ['visibility', 'ci', 'archived', 'branch'] as const;
+
+export type IntrinsicField = (typeof INTRINSIC_FIELDS)[number];
+
+export type ConfigDriftKind =
+	/** The repo is in a subset config but absent from the canonical config. */
+	| 'missing_from_canonical'
+	/** An intrinsic field disagrees between the subset and the canonical config. */
+	| 'field_mismatch';
+
+export interface ConfigDrift {
+	repo_url: string;
+	/** Name of the subset config whose entry diverges. */
+	config: string;
+	kind: ConfigDriftKind;
+	/** The field that disagrees, set when `kind` is `'field_mismatch'`. */
+	field?: IntrinsicField;
+	/** The canonical config's value, set when `kind` is `'field_mismatch'`. */
+	canonical_value?: string;
+	/** The subset config's value, set when `kind` is `'field_mismatch'`. */
+	config_value?: string;
+}
+
+export interface NamedRepos {
+	name: string;
+	repos: Array<GitopsRepoConfig>;
+}
+
+const field_value = (repo: GitopsRepoConfig, field: IntrinsicField): string => {
+	switch (field) {
+		case 'visibility':
+			return repo.visibility;
+		case 'ci':
+			return String(repo.ci);
+		case 'archived':
+			return String(repo.archived);
+		case 'branch':
+			return repo.branch;
+	}
+};
+
+/**
+ * Compares each subset config against the canonical config. Repos that live only
+ * in the canonical config are fine — the subsets are intentional partial views.
+ * @returns one `ConfigDrift` per subset entry that is missing from the canonical
+ * config or whose intrinsic fields disagree with it
+ */
+export const reconcile_configs = (
+	canonical: NamedRepos,
+	subsets: Array<NamedRepos>,
+): Array<ConfigDrift> => {
+	const drift: Array<ConfigDrift> = [];
+	const canonical_by_url = new Map(canonical.repos.map((r) => [r.repo_url, r] as const));
+	for (const subset of subsets) {
+		for (const repo of subset.repos) {
+			const canon = canonical_by_url.get(repo.repo_url);
+			if (!canon) {
+				drift.push({repo_url: repo.repo_url, config: subset.name, kind: 'missing_from_canonical'});
+				continue;
+			}
+			for (const field of INTRINSIC_FIELDS) {
+				const canonical_value = field_value(canon, field);
+				const config_value = field_value(repo, field);
+				if (canonical_value !== config_value) {
+					drift.push({
+						repo_url: repo.repo_url,
+						config: subset.name,
+						kind: 'field_mismatch',
+						field,
+						canonical_value,
+						config_value,
+					});
+				}
+			}
+		}
+	}
+	return drift;
+};

package/src/lib/dependency_graph.ts

@@ -1,17 +1,17 @@
 /**
  * Dependency graph data structure and algorithms for multi-repo publishing.
  *
- * Provides `DependencyGraph` class with topological sort (via `@fuzdev/fuz_util/sort.js`)
+ * Provides `DependencyGraph` class with topological sort (via `@fuzdev/fuz_util/sort.ts`)
  * and cycle detection by dependency type.
  * For validation workflow and publishing order computation, see `graph_validation.ts`.
  *
  * @module
  */
 
-import {EMPTY_OBJECT} from '@fuzdev/fuz_util/object.js';
-import {topological_sort as topological_sort_generic} from '@fuzdev/fuz_util/sort.js';
+import {EMPTY_OBJECT} from '@fuzdev/fuz_util/object.ts';
+import {topological_sort as topological_sort_generic} from '@fuzdev/fuz_util/sort.ts';
 
-import type {LocalRepo} from './local_repo.js';
+import type {LocalRepo} from './local_repo.ts';
 
 export const DEPENDENCY_TYPE = {
 	PROD: 'prod',
@@ -122,7 +122,7 @@ export class DependencyGraph {
 	/**
 	 * Computes topological sort order for dependency graph.
 	 *
-	 * Delegates to `@fuzdev/fuz_util/sort.js` for the sorting algorithm.
+	 * Delegates to `@fuzdev/fuz_util/sort.ts` for the sorting algorithm.
 	 * Throws if cycles detected.
 	 *
 	 * @param exclude_dev - if true, excludes dev dependencies to break cycles

package/src/lib/dependency_updater.ts

@@ -1,15 +1,15 @@
-import type {Logger} from '@fuzdev/fuz_util/log.js';
+import type {Logger} from '@fuzdev/fuz_util/log.ts';
 import {join} from 'node:path';
 
-import type {LocalRepo} from './local_repo.js';
-import type {PublishedVersion} from './multi_repo_publisher.js';
+import type {LocalRepo} from './local_repo.ts';
+import type {PublishedVersion} from './multi_repo_publisher.ts';
 import {
 	create_changeset_for_dependency_updates,
 	create_dependency_updates,
-} from './changeset_generator.js';
-import {needs_update, get_update_prefix} from './version_utils.js';
-import type {GitOperations, FsOperations} from './operations.js';
-import {default_git_operations, default_fs_operations} from './operations_defaults.js';
+} from './changeset_generator.ts';
+import {needs_update, get_update_prefix} from './version_utils.ts';
+import type {GitOperations, FsOperations} from './operations.ts';
+import {default_git_operations, default_fs_operations} from './operations_defaults.ts';
 
 export type VersionStrategy = 'exact' | 'caret' | 'tilde' | 'gte';
 

package/src/lib/fetch_repo_data.ts

@@ -1,10 +1,10 @@
-import type {Logger} from '@fuzdev/fuz_util/log.js';
-import {wait} from '@fuzdev/fuz_util/async.js';
-import type {FetchValueCache} from '@fuzdev/fuz_util/fetch.js';
+import type {Logger} from '@fuzdev/fuz_util/log.ts';
+import {wait} from '@fuzdev/fuz_util/async.ts';
+import type {FetchValueCache} from '@fuzdev/fuz_util/fetch.ts';
 
-import {fetch_github_check_runs, fetch_github_pull_requests} from './github.js';
-import type {RepoJson} from './repo.svelte.js';
-import type {LocalRepo} from './local_repo.js';
+import {fetch_github_check_runs, fetch_github_pull_requests} from './github.ts';
+import type {RepoJson} from './repo.svelte.ts';
+import type {LocalRepo} from './local_repo.ts';
 
 /**
  * Fetches GitHub metadata (CI status, PRs) for all repos.

package/src/lib/fs_fetch_value_cache.ts

@@ -1,8 +1,8 @@
 import {mkdir, readFile, rm, writeFile} from 'node:fs/promises';
 import {dirname, join} from 'node:path';
-import {paths} from '@fuzdev/gro/paths.js';
-import {format_file} from '@fuzdev/gro/format_file.js';
-import {deserialize_cache, serialize_cache, type FetchValueCache} from '@fuzdev/fuz_util/fetch.js';
+import {paths} from '@fuzdev/gro/paths.ts';
+import {format_file} from '@fuzdev/gro/format_file.ts';
+import {deserialize_cache, serialize_cache, type FetchValueCache} from '@fuzdev/fuz_util/fetch.ts';
 import {existsSync} from 'node:fs';
 
 // TODO upstream to Gro probably, and rename/redesign?

package/src/lib/git_operations.ts

@@ -1,4 +1,4 @@
-import {spawn_out, spawn_result_to_message} from '@fuzdev/fuz_util/process.js';
+import {spawn_out, spawn_result_to_message} from '@fuzdev/fuz_util/process.ts';
 import type {SpawnOptions} from 'node:child_process';
 import {
 	git_check_clean_workspace as gro_git_check_clean_workspace,
@@ -8,7 +8,7 @@ import {
 	git_current_commit_hash as gro_git_current_commit_hash,
 	type GitBranch,
 	type GitOrigin,
-} from '@fuzdev/fuz_util/git.js';
+} from '@fuzdev/fuz_util/git.ts';
 
 /**
  * Adds files to git staging area and throws if anything goes wrong.

package/src/lib/github.ts

@@ -1,6 +1,6 @@
-import type {Logger} from '@fuzdev/fuz_util/log.js';
+import type {Logger} from '@fuzdev/fuz_util/log.ts';
 import {z} from 'zod';
-import {fetch_value, type FetchValueCache} from '@fuzdev/fuz_util/fetch.js';
+import {fetch_value, type FetchValueCache} from '@fuzdev/fuz_util/fetch.ts';
 
 /**
  * Minimal interface for GitHub API calls - works with both `Pkg` and `Repo`.

package/src/lib/github_helpers.ts

@@ -1,7 +1,7 @@
-import {ensure_end} from '@fuzdev/fuz_util/string.js';
+import {ensure_end} from '@fuzdev/fuz_util/string.ts';
 
-import type {GithubPullRequest} from './github.js';
-import type {Repo} from './repo.svelte.js';
+import type {GithubPullRequest} from './github.ts';
+import type {Repo} from './repo.svelte.ts';
 
 export type FilterPullRequest = (pull_request: GithubPullRequest, repo: Repo) => boolean;
 

package/src/lib/gitops_analyze.task.ts

@@ -1,19 +1,19 @@
 import type {Task} from '@fuzdev/gro';
 import {z} from 'zod';
 import {styleText as st} from 'node:util';
-import type {Logger} from '@fuzdev/fuz_util/log.js';
+import type {Logger} from '@fuzdev/fuz_util/log.ts';
 
-import {get_gitops_ready} from './gitops_task_helpers.js';
-import type {DependencyGraph} from './dependency_graph.js';
-import type {LocalRepo} from './local_repo.js';
-import {analyze_repos, type DependencyAnalysis} from './graph_validation.js';
+import {get_gitops_ready} from './gitops_task_helpers.ts';
+import type {DependencyGraph} from './dependency_graph.ts';
+import {repo_is_npm} from './local_repo.ts';
+import {analyze_repos, type DependencyAnalysis} from './graph_validation.ts';
 import {
 	format_wildcard_dependencies,
 	format_dev_cycles,
 	format_production_cycles,
-} from './log_helpers.js';
-import {format_and_output, type OutputFormatters} from './output_helpers.js';
-import {GITOPS_CONFIG_PATH_DEFAULT} from './gitops_constants.js';
+} from './log_helpers.ts';
+import {format_and_output, type OutputFormatters} from './output_helpers.ts';
+import {GITOPS_CONFIG_PATH_DEFAULT} from './gitops_constants.ts';
 
 /** @nodocs */
 export const Args = z.strictObject({
@@ -50,12 +50,24 @@ export const task: Task<Args> = {
 		// Get repos ready (without downloading); read the working tree as-is unless `--sync`
 		const {local_repos} = await get_gitops_ready({config, dir, download: false, sync, log});
 
+		// Only npm packages form the dependency graph; note any non-npm repos (e.g. cargo)
+		// that are excluded so the omission isn't silent.
+		const non_npm_repos = local_repos.filter((r) => !repo_is_npm(r));
+		if (non_npm_repos.length > 0) {
+			log.info(
+				st(
+					'dim',
+					`excluding ${non_npm_repos.length} non-npm repo(s) from analysis (dashboard-only): ` +
+						non_npm_repos.map((r) => r.library.name).join(', '),
+				),
+			);
+		}
+
 		// Build the dependency graph and analyze cycles/wildcards (tolerating cycles)
 		const {graph, analysis, publishing_order} = analyze_repos(local_repos);
 
 		// Format and output using output_helpers
 		const data = {
-			repos: local_repos,
 			graph,
 			analysis,
 			publishing_order,
@@ -67,7 +79,6 @@ export const task: Task<Args> = {
 
 // Data type for analysis output
 interface AnalysisData {
-	repos: Array<LocalRepo>;
 	graph: DependencyGraph;
 	analysis: DependencyAnalysis;
 	publishing_order: Array<string> | null;
@@ -76,9 +87,8 @@ interface AnalysisData {
 // Create formatters for output_helpers
 const create_formatters = (): OutputFormatters<AnalysisData> => ({
 	json: (data) => format_json(data.graph, data.analysis, data.publishing_order),
-	markdown: (data) => format_markdown(data.repos, data.graph, data.analysis, data.publishing_order),
-	stdout: (data, log) =>
-		format_stdout(data.repos, data.graph, data.analysis, data.publishing_order, log),
+	markdown: (data) => format_markdown(data.graph, data.analysis, data.publishing_order),
+	stdout: (data, log) => format_stdout(data.graph, data.analysis, data.publishing_order, log),
 });
 
 // Helper to calculate common statistics
@@ -109,7 +119,6 @@ const format_json = (
 };
 
 const format_markdown = (
-	repos: Array<LocalRepo>,
 	graph: DependencyGraph,
 	analysis: DependencyAnalysis,
 	publishing_order: Array<string> | null,
@@ -120,7 +129,7 @@ const format_markdown = (
 	const {total_deps, internal_deps} = calculate_stats(graph);
 
 	lines.push('', '## Summary', '');
-	lines.push(`- **Total packages**: ${repos.length}`);
+	lines.push(`- **Total packages**: ${graph.nodes.size}`);
 	lines.push(`- **Total dependencies**: ${total_deps}`);
 	lines.push(`- **Internal dependencies**: ${internal_deps}`);
 	lines.push(`- **Wildcard dependencies**: ${analysis.wildcard_deps.length}`);
@@ -185,13 +194,12 @@ const format_markdown = (
 };
 
 const format_stdout = (
-	repos: Array<LocalRepo>,
 	graph: DependencyGraph,
 	analysis: DependencyAnalysis,
 	publishing_order: Array<string> | null,
 	log: Logger,
 ): void => {
-	log.info(st('cyan', `📊 Analyzing ${repos.length} repositories...`));
+	log.info(st('cyan', `📊 Analyzing ${graph.nodes.size} repositories...`));
 
 	// Publishing order
 	if (publishing_order) {
@@ -248,7 +256,7 @@ const format_stdout = (
 
 	log.info('');
 	log.info(st('cyan', 'Summary:'));
-	log.info(`  Total packages: ${repos.length}`);
+	log.info(`  Total packages: ${graph.nodes.size}`);
 	log.info(`  Total dependencies: ${total_deps}`);
 	log.info(`  Internal dependencies: ${internal_deps}`);
 	log.info(`  Wildcard dependencies: ${analysis.wildcard_deps.length}`);