diff --git a/Cargo.lock b/Cargo.lock
index 0d17758..369f0ee 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -1581,7 +1581,7 @@ dependencies = [
[[package]]
name = "graphify"
-version = "0.8.49"
+version = "0.9.0"
dependencies = [
"anyhow",
"assert_cmd",
@@ -1621,7 +1621,7 @@ dependencies = [
[[package]]
name = "graphify-affected"
-version = "0.8.49"
+version = "0.9.0"
dependencies = [
"graphify-build",
"graphify-security",
@@ -1634,7 +1634,7 @@ dependencies = [
[[package]]
name = "graphify-analyze"
-version = "0.8.49"
+version = "0.9.0"
dependencies = [
"graphify-build",
"graphify-cluster",
@@ -1646,7 +1646,7 @@ dependencies = [
[[package]]
name = "graphify-benchmark"
-version = "0.8.49"
+version = "0.9.0"
dependencies = [
"graphify-build",
"graphify-security",
@@ -1659,7 +1659,7 @@ dependencies = [
[[package]]
name = "graphify-build"
-version = "0.8.49"
+version = "0.9.0"
dependencies = [
"caseless",
"graphify-security",
@@ -1676,7 +1676,7 @@ dependencies = [
[[package]]
name = "graphify-cache"
-version = "0.8.49"
+version = "0.9.0"
dependencies = [
"graphify-security",
"hex",
@@ -1692,7 +1692,7 @@ dependencies = [
[[package]]
name = "graphify-cluster"
-version = "0.8.49"
+version = "0.9.0"
dependencies = [
"graphify-build",
"indexmap",
@@ -1705,7 +1705,7 @@ dependencies = [
[[package]]
name = "graphify-dedup"
-version = "0.8.49"
+version = "0.9.0"
dependencies = [
"caseless",
"indexmap",
@@ -1720,7 +1720,7 @@ dependencies = [
[[package]]
name = "graphify-detect"
-version = "0.8.49"
+version = "0.9.0"
dependencies = [
"calamine",
"graphify-google",
@@ -1746,7 +1746,7 @@ dependencies = [
[[package]]
name = "graphify-diagnostics"
-version = "0.8.49"
+version = "0.9.0"
dependencies = [
"graphify-build",
"graphify-security",
@@ -1760,7 +1760,7 @@ dependencies = [
[[package]]
name = "graphify-export"
-version = "0.8.49"
+version = "0.9.0"
dependencies = [
"chrono",
"graphify-build",
@@ -1784,7 +1784,7 @@ dependencies = [
[[package]]
name = "graphify-extract"
-version = "0.8.49"
+version = "0.9.0"
dependencies = [
"flate2",
"glob",
@@ -1839,7 +1839,7 @@ dependencies = [
[[package]]
name = "graphify-global"
-version = "0.8.49"
+version = "0.9.0"
dependencies = [
"chrono",
"graphify-build",
@@ -1855,7 +1855,7 @@ dependencies = [
[[package]]
name = "graphify-google"
-version = "0.8.49"
+version = "0.9.0"
dependencies = [
"hex",
"regex",
@@ -1868,7 +1868,7 @@ dependencies = [
[[package]]
name = "graphify-hooks"
-version = "0.8.49"
+version = "0.9.0"
dependencies = [
"regex",
"serde_json",
@@ -1881,7 +1881,7 @@ dependencies = [
[[package]]
name = "graphify-html"
-version = "0.8.49"
+version = "0.9.0"
dependencies = [
"chrono",
"graphify-build",
@@ -1898,7 +1898,7 @@ dependencies = [
[[package]]
name = "graphify-ingest"
-version = "0.8.49"
+version = "0.9.0"
dependencies = [
"chrono",
"graphify-security",
@@ -1916,7 +1916,7 @@ dependencies = [
[[package]]
name = "graphify-llm"
-version = "0.8.49"
+version = "0.9.0"
dependencies = [
"aws-config",
"aws-sdk-bedrockruntime",
@@ -1943,14 +1943,14 @@ dependencies = [
[[package]]
name = "graphify-manifest"
-version = "0.8.49"
+version = "0.9.0"
dependencies = [
"graphify-detect",
]
[[package]]
name = "graphify-multigraph-compat"
-version = "0.8.49"
+version = "0.9.0"
dependencies = [
"graphify-build",
"indexmap",
@@ -1961,7 +1961,7 @@ dependencies = [
[[package]]
name = "graphify-prs"
-version = "0.8.49"
+version = "0.9.0"
dependencies = [
"chrono",
"graphify-security",
@@ -1974,7 +1974,7 @@ dependencies = [
[[package]]
name = "graphify-reflect"
-version = "0.8.49"
+version = "0.9.0"
dependencies = [
"chrono",
"graphify-ingest",
@@ -1987,7 +1987,7 @@ dependencies = [
[[package]]
name = "graphify-report"
-version = "0.8.49"
+version = "0.9.0"
dependencies = [
"chrono",
"graphify-analyze",
@@ -2001,7 +2001,7 @@ dependencies = [
[[package]]
name = "graphify-scip"
-version = "0.8.49"
+version = "0.9.0"
dependencies = [
"graphify-security",
"hex",
@@ -2016,7 +2016,7 @@ dependencies = [
[[package]]
name = "graphify-security"
-version = "0.8.49"
+version = "0.9.0"
dependencies = [
"ipnet",
"mockito",
@@ -2031,7 +2031,7 @@ dependencies = [
[[package]]
name = "graphify-semantic"
-version = "0.8.49"
+version = "0.9.0"
dependencies = [
"indexmap",
"regex",
@@ -2043,7 +2043,7 @@ dependencies = [
[[package]]
name = "graphify-serve"
-version = "0.8.49"
+version = "0.9.0"
dependencies = [
"axum",
"chrono",
@@ -2064,7 +2064,7 @@ dependencies = [
[[package]]
name = "graphify-transcribe"
-version = "0.8.49"
+version = "0.9.0"
dependencies = [
"graphify-security",
"hex",
@@ -2077,7 +2077,7 @@ dependencies = [
[[package]]
name = "graphify-validate"
-version = "0.8.49"
+version = "0.9.0"
dependencies = [
"serde_json",
"thiserror 2.0.18",
@@ -2085,7 +2085,7 @@ dependencies = [
[[package]]
name = "graphify-watch"
-version = "0.8.49"
+version = "0.9.0"
dependencies = [
"graphify-analyze",
"graphify-build",
@@ -2107,7 +2107,7 @@ dependencies = [
[[package]]
name = "graphify-wiki"
-version = "0.8.49"
+version = "0.9.0"
dependencies = [
"graphify-build",
"indexmap",
diff --git a/Cargo.toml b/Cargo.toml
index 3e77608..e320f53 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -44,7 +44,7 @@ license = "Apache-2.0"
publish = false
repository = "https://github.com/bunkerlab-net/graphify"
rust-version = "1.95"
-version = "0.8.49"
+version = "0.9.0"
[workspace.dependencies]
anyhow = "1"
@@ -185,6 +185,7 @@ http = ["graphify-serve/http"]
[dev-dependencies]
assert_cmd = "2"
predicates = "3"
+serde_json = { workspace = true }
tempfile = { workspace = true }
[lints]
diff --git a/README.md b/README.md
index 46f075c..352ac01 100644
--- a/README.md
+++ b/README.md
@@ -47,11 +47,14 @@ a Rust equivalent, and outputs are byte-identical where the test suite asserts i
- **26+ languages**, parsed with tree-sitter: Rust, Python, TypeScript, JavaScript, Go, Java, C, C++, C#, Ruby, PHP,
Swift, Kotlin, Scala, Bash, Lua, Elixir, Haskell, OCaml, Zig, Solidity, R, Julia, HTML, CSS, SQL, …
- Also reads .NET project files (`.sln`, `.csproj`, `.fsproj`, `.vbproj`) and Razor components
+ Vue / Svelte / Astro single-file components (`.vue`, `.svelte`, `.astro`) are parsed through their ` close tag
+ pos = whole.end();
+ if lang.is_none()
+ && let Some(lm) = VUE_SCRIPT_LANG_RE.captures(open)
+ {
+ lang = lm.get(1).map(|m| m.as_str().to_lowercase());
+ }
+ }
+ out.push_str(&blank(&src[pos..]));
+ (out, lang)
+}
+
+/// Extract imports, symbols, and type refs from a `.vue` SFC (#1468).
+///
+/// Masks the non-`\n",
+ );
+ let result = extract_vue(&comp);
+ let targets = targets(&result, "imports_from");
+ assert!(
+ targets.contains(&id_for(&tmp.path().join("Child.vue"))),
+ "{targets:?}"
+ );
+ assert!(
+ targets.contains(&id_for(&tmp.path().join("utils/helper.ts"))),
+ "{targets:?}"
+ );
+}
+
+#[test]
+fn vue_script_setup_extracts_symbols_with_correct_lines() {
+ let tmp = tempfile::tempdir().expect("tempdir");
+ let comp = write_file(
+ &tmp.path().join("Widget.vue"),
+ "\n \n\n\n\
+ \n",
+ );
+ let result = extract_vue(&comp);
+ let count = result.nodes.iter().find(|n| n.label == "count");
+ let on_click = result.nodes.iter().find(|n| n.label == "onClick()");
+ assert!(count.is_some(), "no `count` node");
+ assert!(on_click.is_some(), "no `onClick()` node");
+ // `count` is declared on line 8, `onClick` on line 10 of the SFC (preserved
+ // line numbers prove the mask kept newlines).
+ assert_eq!(count.unwrap().source_location.as_deref(), Some("L8"));
+ assert_eq!(on_click.unwrap().source_location.as_deref(), Some("L10"));
+}
+
+#[test]
+fn vue_dynamic_import_recovered() {
+ let tmp = tempfile::tempdir().expect("tempdir");
+ write_file(
+ &tmp.path().join("Lazy.vue"),
+ "\n",
+ );
+ let comp = write_file(
+ &tmp.path().join("Host.vue"),
+ "\n\n\
+ \n",
+ );
+ let result = extract_vue(&comp);
+ assert!(targets(&result, "dynamic_import").contains(&id_for(&tmp.path().join("Lazy.vue"))));
+}
+
+#[test]
+fn vue_plain_js_script_block() {
+ let tmp = tempfile::tempdir().expect("tempdir");
+ write_file(&tmp.path().join("dep.js"), "export const x = 1\n");
+ let comp = write_file(
+ &tmp.path().join("Legacy.vue"),
+ "\n\n\
+ \n",
+ );
+ let result = extract_vue(&comp);
+ assert!(targets(&result, "imports_from").contains(&id_for(&tmp.path().join("dep.js"))));
+}
+
+#[test]
+fn vue_two_script_blocks_both_parsed() {
+ let tmp = tempfile::tempdir().expect("tempdir");
+ write_file(&tmp.path().join("a.ts"), "export const a = 1\n");
+ write_file(&tmp.path().join("b.ts"), "export const b = 2\n");
+ let comp = write_file(
+ &tmp.path().join("Dual.vue"),
+ "\n\n\
+ \n\n\
+ \n",
+ );
+ let result = extract_vue(&comp);
+ let targets = targets(&result, "imports_from");
+ assert!(
+ targets.contains(&id_for(&tmp.path().join("a.ts"))),
+ "{targets:?}"
+ );
+ assert!(
+ targets.contains(&id_for(&tmp.path().join("b.ts"))),
+ "{targets:?}"
+ );
+}
+
+#[test]
+fn vue_template_only_file_does_not_crash() {
+ let tmp = tempfile::tempdir().expect("tempdir");
+ let comp = write_file(
+ &tmp.path().join("Static.vue"),
+ "\n hi
\n\n",
+ );
+ let result = extract_vue(&comp);
+ // No `\n",
+ );
+ let result = extract_vue(&comp);
+ assert!(targets(&result, "imports_from").contains(&id_for(&tmp.path().join("dep.ts"))));
+}
+
+#[test]
+fn vue_generic_component_open_tag_with_angle_brackets() {
+ // A Vue 3.3+ `generic=` attribute containing '>' (Record)
+ // must not prematurely end the \n",
+ );
+ let result = extract_vue(&comp);
+ assert!(
+ targets(&result, "imports_from").contains(&id_for(&tmp.path().join("utils/helper.ts"))),
+ "import inside a generic-component script body must be recovered"
+ );
+}
+
+#[test]
+fn vue_joins_cross_file_symbol_resolution() {
+ // A `.vue` calling an imported function wires to the real symbol across files,
+ // like any `.ts` file would.
+ let tmp = tempfile::tempdir().expect("tempdir");
+ let helper = write_file(
+ &tmp.path().join("helper.ts"),
+ "export function helper() {}\n",
+ );
+ let comp = write_file(
+ &tmp.path().join("Caller.vue"),
+ "\n\n\
+ \n",
+ );
+ let result = extract(&[comp, helper], Some(tmp.path()));
+ let by_label: std::collections::HashMap<&str, &str> = result
+ .nodes
+ .iter()
+ .filter_map(|n| {
+ Some((
+ n.get("label").and_then(|v| v.as_str())?,
+ n.get("id").and_then(|v| v.as_str())?,
+ ))
+ })
+ .collect();
+ let (Some(go), Some(helper_id)) = (by_label.get("go()"), by_label.get("helper()")) else {
+ panic!(
+ "missing go()/helper() nodes: {:?}",
+ by_label.keys().collect::>()
+ );
+ };
+ let edge_exists = result.edges.iter().any(|e| {
+ e.get("source").and_then(|v| v.as_str()) == Some(go)
+ && e.get("target").and_then(|v| v.as_str()) == Some(helper_id)
+ && e.get("relation").and_then(|v| v.as_str()) == Some("calls")
+ });
+ assert!(edge_exists, "go() -> helper() calls edge missing");
+}
diff --git a/crates/graphify-hooks/src/platform/common/hooks_json.rs b/crates/graphify-hooks/src/platform/common/hooks_json.rs
index 1e9ece2..baf8c80 100644
--- a/crates/graphify-hooks/src/platform/common/hooks_json.rs
+++ b/crates/graphify-hooks/src/platform/common/hooks_json.rs
@@ -42,15 +42,21 @@ pub(in crate::platform) fn settings_hook() -> Value {
/// file outside `graphify-out/` when a graph exists. The parser is `python3`,
/// the shell is POSIX, and every branch fails open, so a legitimate read always
/// goes through. Reading the graph's own report under `graphify-out/` is
-/// suppressed so it never starts a feedback loop. The command is byte-identical
-/// to the Python reference so the rendered settings file matches exactly.
+/// suppressed so it never starts a feedback loop.
///
-/// The command is deliberately kept as one whole literal rather than composed
-/// from fragments (a reviewer suggested decomposing it): it must stay
-/// byte-for-byte identical to graphify-py's `_READ_SETTINGS_HOOK["command"]`,
-/// and a single literal makes that correspondence verifiable at a glance. Its
-/// runtime behaviour is validated by `tests/read_hook.rs`, which executes it via
-/// `sh -c` against crafted stdin.
+/// The extension test compares each value's real trailing extension — the
+/// segment after the last `/`, then after the last `.` — against the known set
+/// (not a substring scan, which both missed framework files like `.astro` and
+/// false-matched `.json` against `.js`, #1463); `.astro` / `.vue` / `.svelte`
+/// are included.
+///
+/// The extension-matching command body mirrors graphify-py's
+/// `_READ_SETTINGS_HOOK["command"]`; it is kept as one whole literal rather than
+/// composed from fragments so the correspondence is verifiable at a glance. The
+/// nudge *message* is a deliberate, pre-existing divergence — graphify-py phrases
+/// it as `MANDATORY …`, the Rust port keeps its softer wording. Runtime
+/// behaviour is validated by `tests/read_hook.rs`, which executes it via `sh -c`
+/// against crafted stdin.
#[must_use]
pub(in crate::platform) fn read_settings_hook() -> Value {
serde_json::json!({
@@ -58,7 +64,7 @@ pub(in crate::platform) fn read_settings_hook() -> Value {
"hooks": [
{
"type": "command",
- "command": r#"HIT=$(python3 -c "import json,sys;d=json.load(sys.stdin);t=d.get('tool_input',d);s=(str(t.get('file_path') or '')+' '+str(t.get('pattern') or '')+' '+str(t.get('path') or '')).lower().replace(chr(92),'/');exts=('.py','.js','.ts','.tsx','.jsx','.go','.rs','.java','.rb','.c','.h','.cpp','.hpp','.cc','.cs','.kt','.swift','.php','.scala','.lua','.sh','.md','.rst','.txt','.mdx');sys.stdout.write('1' if 'graphify-out/' not in s and any(e in s for e in exts) else '')" 2>/dev/null || true); if [ "$HIT" = 1 ] && [ -f graphify-out/graph.json ]; then echo '{"hookSpecificOutput":{"hookEventName":"PreToolUse","additionalContext":"graphify: knowledge graph at graphify-out/. For codebase questions, run `graphify query \"\"` (scoped subgraph, usually much smaller than reading files one by one), `graphify explain \"\"`, or `graphify path \"\" \"\"`, instead of reading source files to answer. Read raw files to modify or debug specific code, or when the graph lacks the detail."}}'; fi || true"#
+ "command": r#"HIT=$(python3 -c "import json,sys;d=json.load(sys.stdin);t=d.get('tool_input',d);exts=('.py','.js','.ts','.tsx','.jsx','.astro','.vue','.svelte','.go','.rs','.java','.rb','.c','.h','.cpp','.hpp','.cc','.cs','.kt','.swift','.php','.scala','.lua','.sh','.md','.rst','.txt','.mdx');vals=[str(t.get('file_path') or ''),str(t.get('pattern') or ''),str(t.get('path') or '')];j=' '.join(vals).lower().replace(chr(92),'/');tails=[('.'+x.rsplit('.',1)[-1]) for v in vals if v for x in [v.lower().replace(chr(92),'/').rsplit('/',1)[-1]] if '.' in x];sys.stdout.write('1' if 'graphify-out/' not in j and any(tl in exts for tl in tails) else '')" 2>/dev/null || true); if [ "$HIT" = 1 ] && [ -f graphify-out/graph.json ]; then echo '{"hookSpecificOutput":{"hookEventName":"PreToolUse","additionalContext":"graphify: knowledge graph at graphify-out/. For codebase questions, run `graphify query \"\"` (scoped subgraph, usually much smaller than reading files one by one), `graphify explain \"\"`, or `graphify path \"\" \"\"`, instead of reading source files to answer. Read raw files to modify or debug specific code, or when the graph lacks the detail."}}'; fi || true"#
}
]
})
diff --git a/crates/graphify-hooks/tests/read_hook.rs b/crates/graphify-hooks/tests/read_hook.rs
index 491f743..909d55d 100644
--- a/crates/graphify-hooks/tests/read_hook.rs
+++ b/crates/graphify-hooks/tests/read_hook.rs
@@ -181,3 +181,79 @@ fn never_blocks() {
assert!(!s.contains("\"permissionDecision\""));
assert!(!s.contains("\"deny\""));
}
+
+#[test]
+fn nudges_on_framework_source() {
+ // .astro/.vue/.svelte are real source types and must nudge (#1463).
+ let tmp = tempfile::tempdir().expect("tempdir");
+ let cmd = read_hook_command(tmp.path());
+ for path in [
+ "src/components/Hero.astro",
+ "src/App.vue",
+ "src/Card.svelte",
+ ] {
+ let out = run(&cmd, &json!({ "file_path": path }), tmp.path(), true);
+ assert!(
+ stdout_of(&out).contains("graphify query"),
+ "{path} should nudge"
+ );
+ }
+}
+
+#[test]
+fn astro_glob_nudges() {
+ let tmp = tempfile::tempdir().expect("tempdir");
+ let cmd = read_hook_command(tmp.path());
+ let out = run(&cmd, &json!({"pattern": "**/*.astro"}), tmp.path(), true);
+ assert!(stdout_of(&out).contains("graphify query"));
+}
+
+#[test]
+fn silent_on_json_config() {
+ // Config files stay silent: `.json` must not match the `.js` extension (#1463).
+ let tmp = tempfile::tempdir().expect("tempdir");
+ let cmd = read_hook_command(tmp.path());
+ for path in ["package.json", "tsconfig.json", "data.geojson"] {
+ let out = run(&cmd, &json!({ "file_path": path }), tmp.path(), true);
+ assert_eq!(stdout_of(&out).trim(), "", "{path} should not nudge");
+ }
+}
+
+#[test]
+fn nudges_on_multi_dot_source() {
+ // The real trailing extension wins on multi-dot names (#1463):
+ // a.test.tsx -> .tsx, foo.min.js -> .js.
+ let tmp = tempfile::tempdir().expect("tempdir");
+ let cmd = read_hook_command(tmp.path());
+ for path in ["src/a.test.tsx", "lib/foo.min.js"] {
+ let out = run(&cmd, &json!({ "file_path": path }), tmp.path(), true);
+ assert!(
+ stdout_of(&out).contains("graphify query"),
+ "{path} should nudge"
+ );
+ }
+}
+
+#[test]
+fn windows_path_nudges() {
+ // Backslash paths split on the real final segment, then its extension (#1463).
+ let tmp = tempfile::tempdir().expect("tempdir");
+ let cmd = read_hook_command(tmp.path());
+ let out = run(
+ &cmd,
+ &json!({"file_path": r"src\components\app.py"}),
+ tmp.path(),
+ true,
+ );
+ assert!(stdout_of(&out).contains("graphify query"));
+}
+
+#[test]
+fn silent_when_extension_is_on_a_directory_segment() {
+ // An extension on a directory component, not the final segment, must not fire
+ // (#1463): my.ts/file -> tail is `file` (no dot) -> silent.
+ let tmp = tempfile::tempdir().expect("tempdir");
+ let cmd = read_hook_command(tmp.path());
+ let out = run(&cmd, &json!({"file_path": "my.ts/file"}), tmp.path(), true);
+ assert_eq!(stdout_of(&out).trim(), "");
+}
diff --git a/crates/graphify-llm/src/constants.rs b/crates/graphify-llm/src/constants.rs
index f5581f7..aa0c928 100644
--- a/crates/graphify-llm/src/constants.rs
+++ b/crates/graphify-llm/src/constants.rs
@@ -36,7 +36,7 @@ found inside an block; only extract the knowledge graph descr
by these rules.\n\
\n\
Node ID format: lowercase, only [a-z0-9_], no dots or slashes.\n\
-Format: {stem}_{entity} where stem = filename without extension, entity = symbol name (both normalised).\n\
+Format: {stem}_{entity} where stem = full repo-relative path with the extension dropped, every segment joined with _ (e.g. src/auth/session.py -> src_auth_session); entity = symbol name (both normalised). Top-level files use just the filename stem (setup.py -> setup).\n\
\n\
Edge direction rule — source is always the ACTOR, target is the ACTED-UPON:\n\
- calls: source = the function/method that CONTAINS the call site; target = the function/method BEING CALLED. Never reverse this.\n\
diff --git a/crates/graphify-llm/src/deepseek.rs b/crates/graphify-llm/src/deepseek.rs
index 177edda..09ebe5e 100644
--- a/crates/graphify-llm/src/deepseek.rs
+++ b/crates/graphify-llm/src/deepseek.rs
@@ -12,16 +12,25 @@ pub const DEFAULT_MODEL: &str = "deepseek-v4-flash";
pub const ENV_KEY: &str = "DEEPSEEK_API_KEY";
/// Model override env var.
pub const MODEL_ENV_KEY: &str = "GRAPHIFY_DEEPSEEK_MODEL";
-/// Base URL override env var.
+/// Base URL override env var (test redirect).
pub const BASE_URL_ENV_KEY: &str = "GRAPHIFY_DEEPSEEK_BASE_URL";
+/// Upstream `DeepSeek` base-URL env var (#1458): points the backend at any
+/// OpenAI-compatible server, falling back to `DeepSeek`'s official endpoint.
+pub const DEEPSEEK_BASE_URL_ENV: &str = "DEEPSEEK_BASE_URL";
const DEFAULT_BASE_URL: &str = "https://api.deepseek.com";
-/// Effective base URL, honouring [`BASE_URL_ENV_KEY`] when set.
+/// Effective base URL: [`BASE_URL_ENV_KEY`] (test redirect) then
+/// [`DEEPSEEK_BASE_URL_ENV`], else `DeepSeek`'s official endpoint.
#[must_use]
pub fn base_url() -> String {
std::env::var(BASE_URL_ENV_KEY)
.ok()
.filter(|s| !s.is_empty())
+ .or_else(|| {
+ std::env::var(DEEPSEEK_BASE_URL_ENV)
+ .ok()
+ .filter(|s| !s.is_empty())
+ })
.unwrap_or_else(|| DEFAULT_BASE_URL.to_string())
}
diff --git a/crates/graphify-llm/src/gemini.rs b/crates/graphify-llm/src/gemini.rs
index 111b3ce..b26b92d 100644
--- a/crates/graphify-llm/src/gemini.rs
+++ b/crates/graphify-llm/src/gemini.rs
@@ -15,16 +15,25 @@ pub const ENV_KEY: &str = "GEMINI_API_KEY";
pub const ENV_KEY_FALLBACK: &str = "GOOGLE_API_KEY";
/// Model override env var.
pub const MODEL_ENV_KEY: &str = "GRAPHIFY_GEMINI_MODEL";
-/// Base URL override env var.
+/// Base URL override env var (test redirect).
pub const BASE_URL_ENV_KEY: &str = "GRAPHIFY_GEMINI_BASE_URL";
+/// Upstream Gemini base-URL env var (#1458): points the backend at any
+/// OpenAI-compatible server, falling back to Google's official endpoint.
+pub const GEMINI_BASE_URL_ENV: &str = "GEMINI_BASE_URL";
const DEFAULT_BASE_URL: &str = "https://generativelanguage.googleapis.com/v1beta/openai/";
-/// Effective base URL, honouring [`BASE_URL_ENV_KEY`] when set.
+/// Effective base URL: [`BASE_URL_ENV_KEY`] (test redirect) then
+/// [`GEMINI_BASE_URL_ENV`], else Google's official endpoint.
#[must_use]
pub fn base_url() -> String {
std::env::var(BASE_URL_ENV_KEY)
.ok()
.filter(|s| !s.is_empty())
+ .or_else(|| {
+ std::env::var(GEMINI_BASE_URL_ENV)
+ .ok()
+ .filter(|s| !s.is_empty())
+ })
.unwrap_or_else(|| DEFAULT_BASE_URL.to_string())
}
diff --git a/crates/graphify-llm/src/kimi.rs b/crates/graphify-llm/src/kimi.rs
index 6527dcf..2e0eee3 100644
--- a/crates/graphify-llm/src/kimi.rs
+++ b/crates/graphify-llm/src/kimi.rs
@@ -14,16 +14,25 @@ use crate::{LlmBackend, LlmError, LlmResponse};
pub const DEFAULT_MODEL: &str = "kimi-k2.6";
/// API key env var.
pub const ENV_KEY: &str = "MOONSHOT_API_KEY";
-/// Base URL override env var.
+/// Base URL override env var (test redirect).
pub const BASE_URL_ENV_KEY: &str = "GRAPHIFY_KIMI_BASE_URL";
+/// Upstream Moonshot/Kimi base-URL env var (#1458): points the backend at any
+/// OpenAI-compatible server (`LiteLLM`, self-hosted proxy, …).
+pub const KIMI_BASE_URL_ENV: &str = "KIMI_BASE_URL";
const DEFAULT_BASE_URL: &str = "https://api.moonshot.ai/v1";
-/// Effective base URL, honouring [`BASE_URL_ENV_KEY`] when set.
+/// Effective base URL: [`BASE_URL_ENV_KEY`] (test redirect) then
+/// [`KIMI_BASE_URL_ENV`], else Moonshot's official endpoint.
#[must_use]
pub fn base_url() -> String {
std::env::var(BASE_URL_ENV_KEY)
.ok()
.filter(|s| !s.is_empty())
+ .or_else(|| {
+ std::env::var(KIMI_BASE_URL_ENV)
+ .ok()
+ .filter(|s| !s.is_empty())
+ })
.unwrap_or_else(|| DEFAULT_BASE_URL.to_string())
}
@@ -151,6 +160,9 @@ pub(crate) fn call_plain_openai_compat(req: &PlainOpenAiRequest<'_>) -> Result) -> Value {
"model": req.model,
"messages": req.messages,
"max_completion_tokens": req.max_completion_tokens,
+ // Force a single non-streamed response: some OpenAI-compatible gateways
+ // default to SSE streaming when `stream` is omitted, but the result is
+ // always read as a single response (#1223).
+ "stream": false,
});
if let Some(t) = resolve_temperature(req.temperature, req.model) {
body["temperature"] = json!(t);
diff --git a/crates/graphify-llm/tests/custom_endpoint.rs b/crates/graphify-llm/tests/custom_endpoint.rs
index b5b32a3..a907c5a 100644
--- a/crates/graphify-llm/tests/custom_endpoint.rs
+++ b/crates/graphify-llm/tests/custom_endpoint.rs
@@ -7,7 +7,7 @@
//! scrubs the relevant vars under `#[serial(env)]`.
#![allow(clippy::expect_used, unsafe_code)]
-use graphify_llm::{backend_config, claude, openai};
+use graphify_llm::{backend_config, claude, deepseek, gemini, kimi, openai};
use serial_test::serial;
mod common;
@@ -119,3 +119,61 @@ fn openai_compat_backends_resolve_full_output_cap() {
// The openai backend's own default-max-tokens helper agrees.
assert_eq!(openai::default_max_tokens(), 16_384);
}
+
+// ── kimi / gemini / deepseek bare *_BASE_URL env overrides (#1458) ────────────
+
+#[test]
+#[serial(env)]
+fn kimi_base_url_honors_bare_env() {
+ let mut g = EnvGuard::new();
+ g.unset("GRAPHIFY_KIMI_BASE_URL")
+ .set("KIMI_BASE_URL", "https://proxy.example/kimi/v1");
+ assert_eq!(kimi::base_url(), "https://proxy.example/kimi/v1");
+}
+
+#[test]
+#[serial(env)]
+fn gemini_base_url_honors_bare_env() {
+ let mut g = EnvGuard::new();
+ g.unset("GRAPHIFY_GEMINI_BASE_URL")
+ .set("GEMINI_BASE_URL", "https://proxy.example/gemini");
+ assert_eq!(gemini::base_url(), "https://proxy.example/gemini");
+}
+
+#[test]
+#[serial(env)]
+fn deepseek_base_url_honors_bare_env() {
+ let mut g = EnvGuard::new();
+ g.unset("GRAPHIFY_DEEPSEEK_BASE_URL")
+ .set("DEEPSEEK_BASE_URL", "https://proxy.example/deepseek");
+ assert_eq!(deepseek::base_url(), "https://proxy.example/deepseek");
+}
+
+#[test]
+#[serial(env)]
+fn kimi_gemini_deepseek_defaults_without_env() {
+ let mut g = EnvGuard::new();
+ g.unset("GRAPHIFY_KIMI_BASE_URL")
+ .unset("KIMI_BASE_URL")
+ .unset("GRAPHIFY_GEMINI_BASE_URL")
+ .unset("GEMINI_BASE_URL")
+ .unset("GRAPHIFY_DEEPSEEK_BASE_URL")
+ .unset("DEEPSEEK_BASE_URL");
+ assert_eq!(kimi::base_url(), "https://api.moonshot.ai/v1");
+ assert_eq!(
+ gemini::base_url(),
+ "https://generativelanguage.googleapis.com/v1beta/openai/"
+ );
+ assert_eq!(deepseek::base_url(), "https://api.deepseek.com");
+}
+
+#[test]
+#[serial(env)]
+fn graphify_kimi_base_url_wins_over_bare() {
+ // The GRAPHIFY_-prefixed test-redirect var takes priority over the bare one,
+ // mirroring the openai precedence.
+ let mut g = EnvGuard::new();
+ g.set("KIMI_BASE_URL", "https://upstream/kimi/v1")
+ .set("GRAPHIFY_KIMI_BASE_URL", "https://redirect/kimi/v1");
+ assert_eq!(kimi::base_url(), "https://redirect/kimi/v1");
+}
diff --git a/crates/graphify-llm/tests/openai_compat_http.rs b/crates/graphify-llm/tests/openai_compat_http.rs
index c77ed52..bfb11a3 100644
--- a/crates/graphify-llm/tests/openai_compat_http.rs
+++ b/crates/graphify-llm/tests/openai_compat_http.rs
@@ -78,6 +78,30 @@ fn call_openai_compat_happy_path() {
assert_eq!(resp.nodes.len(), 1);
}
+/// #1223: the chat-completion request must carry `stream: false` so SSE-default
+/// gateways return a single response. The mock only matches when the body
+/// contains `stream: false`; a missing field makes the mock 501 and the call
+/// fails, so a green call proves the field is present.
+#[test]
+fn call_openai_compat_forces_non_streaming() {
+ let _g = AllowPrivate::new();
+ let mut server = mockito::Server::new();
+ let body = json!({
+ "choices": [{"message": {"content": "{\"nodes\":[],\"edges\":[]}"}, "finish_reason": "stop"}],
+ "usage": {"prompt_tokens": 1, "completion_tokens": 1}
+ });
+ let _m = server
+ .mock("POST", "/chat/completions")
+ .match_body(mockito::Matcher::PartialJson(json!({"stream": false})))
+ .with_status(200)
+ .with_header("Content-Type", "application/json")
+ .with_body(body.to_string())
+ .create();
+ let url = server.url();
+ let req = make_req(&url, "openai");
+ call_openai_compat(&req).expect("request body must carry stream:false");
+}
+
// ── hollow response → reclassified as "length" ─────────────────────────────
#[test]
diff --git a/crates/graphify-reflect/src/lib.rs b/crates/graphify-reflect/src/lib.rs
index a465ae7..1292a96 100644
--- a/crates/graphify-reflect/src/lib.rs
+++ b/crates/graphify-reflect/src/lib.rs
@@ -44,12 +44,13 @@ pub const DEFAULT_MIN_CORROBORATION: usize = 2;
pub(crate) const UNCATEGORIZED: &str = "Uncategorized";
/// `true` if `out_path` exists and is at least as new as every input that feeds
-/// it (the memory docs, and the graph when one is used).
+/// it (the memory docs, and `graph.json` plus its `.graphify_analysis.json` /
+/// `.graphify_labels.json` sidecars when a graph is used, #1470).
///
/// Lets `graphify reflect --if-stale` skip a redundant run. A missing output is
/// never fresh (it must be built). Mtime-based and best-effort.
#[must_use]
-pub fn lessons_fresh(out_path: &Path, memory_dir: &Path, graph_path: Option<&Path>) -> bool {
+pub fn lessons_fresh(out_path: &Path, memory_dir: &Path, graphs: GraphPaths<'_>) -> bool {
let Ok(out_mtime) = std::fs::metadata(out_path).and_then(|m| m.modified()) else {
return false; // missing/unreadable -> must build
};
@@ -67,10 +68,22 @@ pub fn lessons_fresh(out_path: &Path, memory_dir: &Path, graph_path: Option<&Pat
}
}
}
- if let Some(gp) = graph_path
- && let Ok(mtime) = std::fs::metadata(gp).and_then(|m| m.modified())
- {
- newest = newest.max(mtime);
+ // The graph and its sidecars all feed the grouped lessons doc, so any one of
+ // them being newer than the output makes the doc stale (#1470).
+ if let Some(graph) = graphs.graph {
+ let analysis = graphs.analysis.map_or_else(
+ || sibling(graph, ".graphify_analysis.json"),
+ Path::to_path_buf,
+ );
+ let labels = graphs.labels.map_or_else(
+ || sibling(graph, ".graphify_labels.json"),
+ Path::to_path_buf,
+ );
+ for input in [graph.to_path_buf(), analysis, labels] {
+ if let Ok(mtime) = std::fs::metadata(&input).and_then(|m| m.modified()) {
+ newest = newest.max(mtime);
+ }
+ }
}
out_mtime >= newest
}
diff --git a/crates/graphify-reflect/tests/parity.rs b/crates/graphify-reflect/tests/parity.rs
index 51daf84..6ac334b 100644
--- a/crates/graphify-reflect/tests/parity.rs
+++ b/crates/graphify-reflect/tests/parity.rs
@@ -6,8 +6,8 @@ use std::collections::HashSet;
use chrono::{DateTime, Duration, TimeZone, Utc};
use graphify_ingest::save_query_result;
use graphify_reflect::{
- AggResult, MemoryDoc, aggregate_lessons, lessons_fresh, load_memory_docs, parse_memory_doc,
- reflect, render_lessons_md,
+ AggResult, GraphPaths, MemoryDoc, aggregate_lessons, lessons_fresh, load_memory_docs,
+ parse_memory_doc, reflect, render_lessons_md,
};
use indexmap::IndexMap;
@@ -583,58 +583,116 @@ fn second_session_benefits_from_the_first() {
// --- lessons_fresh -------------------------------------------------------------
+type TestResult = Result<(), Box>;
+
#[test]
-fn lessons_fresh_missing_output_is_not_fresh() {
- let tmp = tempfile::tempdir().unwrap();
+fn lessons_fresh_missing_output_is_not_fresh() -> TestResult {
+ let tmp = tempfile::tempdir()?;
let mem = tmp.path().join("memory");
- std::fs::create_dir_all(&mem).unwrap();
- std::fs::write(mem.join("q.md"), "x").unwrap();
- assert!(!lessons_fresh(&tmp.path().join("LESSONS.md"), &mem, None));
+ std::fs::create_dir_all(&mem)?;
+ std::fs::write(mem.join("q.md"), "x")?;
+ assert!(!lessons_fresh(
+ &tmp.path().join("LESSONS.md"),
+ &mem,
+ GraphPaths::default()
+ ));
+ Ok(())
}
#[test]
-fn lessons_fresh_true_when_output_newer_than_inputs() {
- let tmp = tempfile::tempdir().unwrap();
+fn lessons_fresh_true_when_output_newer_than_inputs() -> TestResult {
+ let tmp = tempfile::tempdir()?;
let mem = tmp.path().join("memory");
- std::fs::create_dir_all(&mem).unwrap();
+ std::fs::create_dir_all(&mem)?;
let doc = mem.join("q.md");
- std::fs::write(&doc, "x").unwrap();
+ std::fs::write(&doc, "x")?;
let out = tmp.path().join("LESSONS.md");
- std::fs::write(&out, "y").unwrap();
+ std::fs::write(&out, "y")?;
set_mtime(&doc, 1000);
set_mtime(&out, 2000);
- assert!(lessons_fresh(&out, &mem, None));
+ assert!(lessons_fresh(&out, &mem, GraphPaths::default()));
+ Ok(())
}
#[test]
-fn lessons_fresh_false_when_memory_newer() {
- let tmp = tempfile::tempdir().unwrap();
+fn lessons_fresh_false_when_memory_newer() -> TestResult {
+ let tmp = tempfile::tempdir()?;
let mem = tmp.path().join("memory");
- std::fs::create_dir_all(&mem).unwrap();
+ std::fs::create_dir_all(&mem)?;
let doc = mem.join("q.md");
- std::fs::write(&doc, "x").unwrap();
+ std::fs::write(&doc, "x")?;
let out = tmp.path().join("LESSONS.md");
- std::fs::write(&out, "y").unwrap();
+ std::fs::write(&out, "y")?;
set_mtime(&out, 1000);
set_mtime(&doc, 2000);
- assert!(!lessons_fresh(&out, &mem, None));
+ assert!(!lessons_fresh(&out, &mem, GraphPaths::default()));
+ Ok(())
}
#[test]
-fn lessons_fresh_false_when_graph_newer() {
- let tmp = tempfile::tempdir().unwrap();
+fn lessons_fresh_false_when_graph_newer() -> TestResult {
+ let tmp = tempfile::tempdir()?;
let mem = tmp.path().join("memory");
- std::fs::create_dir_all(&mem).unwrap();
+ std::fs::create_dir_all(&mem)?;
let doc = mem.join("q.md");
- std::fs::write(&doc, "x").unwrap();
+ std::fs::write(&doc, "x")?;
let out = tmp.path().join("LESSONS.md");
- std::fs::write(&out, "y").unwrap();
+ std::fs::write(&out, "y")?;
let graph = tmp.path().join("graph.json");
- std::fs::write(&graph, "{}").unwrap();
+ std::fs::write(&graph, "{}")?;
set_mtime(&doc, 1000);
set_mtime(&out, 1500);
set_mtime(&graph, 2000);
- assert!(!lessons_fresh(&out, &mem, Some(&graph)));
+ assert!(!lessons_fresh(
+ &out,
+ &mem,
+ GraphPaths {
+ graph: Some(&graph),
+ ..Default::default()
+ }
+ ));
+ Ok(())
+}
+
+/// A graph sidecar (`.graphify_analysis.json` / `.graphify_labels.json`) newer
+/// than the output makes lessons stale even when graph.json itself is older
+/// (#1470). Exercises BOTH sidecars (mirrors the Python parametrized test).
+fn assert_stale_when_sidecar_newer(sidecar_name: &str) -> TestResult {
+ let tmp = tempfile::tempdir()?;
+ let mem = tmp.path().join("memory");
+ std::fs::create_dir_all(&mem)?;
+ let doc = mem.join("q.md");
+ std::fs::write(&doc, "x")?;
+ let out = tmp.path().join("LESSONS.md");
+ std::fs::write(&out, "y")?;
+ let graph = tmp.path().join("graph.json");
+ std::fs::write(&graph, "{}")?;
+ let sidecar = tmp.path().join(sidecar_name);
+ std::fs::write(&sidecar, "{}")?;
+ set_mtime(&doc, 1000);
+ set_mtime(&graph, 1000);
+ set_mtime(&out, 1500);
+ // The sidecar (resolved as graph's sibling) is newer than the output.
+ set_mtime(&sidecar, 2000);
+ assert!(!lessons_fresh(
+ &out,
+ &mem,
+ GraphPaths {
+ graph: Some(&graph),
+ ..Default::default()
+ }
+ ));
+ Ok(())
+}
+
+#[test]
+fn lessons_fresh_false_when_analysis_newer() -> TestResult {
+ assert_stale_when_sidecar_newer(".graphify_analysis.json")
+}
+
+#[test]
+fn lessons_fresh_false_when_labels_newer() -> TestResult {
+ assert_stale_when_sidecar_newer(".graphify_labels.json")
}
/// Set a file's mtime to `secs` after the Unix epoch.
diff --git a/crates/graphify-serve/src/graph.rs b/crates/graphify-serve/src/graph.rs
index 73f523c..150a1e0 100644
--- a/crates/graphify-serve/src/graph.rs
+++ b/crates/graphify-serve/src/graph.rs
@@ -98,6 +98,18 @@ pub fn load_graph(graph_path: &str) -> Result {
obj.insert("directed".to_string(), Value::Bool(true));
}
+ // #1504: nudge once when the on-disk graph still uses the pre-path-qualified
+ // node-ID scheme, so an MCP session sees the same advice as the CLI. Inspect
+ // the raw nodes before `build_from_json` moves `data`; silent on fresh graphs.
+ if let Some(nodes) = data.get("nodes").and_then(Value::as_array)
+ && graphify_build::graph_has_legacy_ids(nodes, None)
+ {
+ eprintln!(
+ "[graphify] note: this graph uses the pre-#1504 node-ID scheme; \
+ rebuild with `graphify extract --force` for path-qualified IDs."
+ );
+ }
+
graphify_build::build_from_json(data, true, None).map_err(|e| ServeError::Io(format!("{e}")))
}
@@ -727,9 +739,13 @@ pub fn subgraph_to_text(
// ── Find node ─────────────────────────────────────────────────────────────────
-/// Return node IDs whose label or ID matches search term (diacritic-insensitive).
+/// Return node IDs whose source-file path, label, or ID matches the search term
+/// (diacritic-insensitive).
///
-/// Ordered: exact, prefix, substring.
+/// Ordered: exact source-file path, then exact (label/ID), prefix, substring.
+/// When a source-file path matches several nodes (a file node plus the symbols
+/// inside it), the L1 file node whose basename equals the query basename is
+/// floated to the front so a path query lands on the file, not a symbol (#1503).
///
/// Both the query and the node label/ID are run through [`search_tokens`] so
/// punctuated names (`foo.bar`, `foo()`, `pkg::Type`) match a tokenised query.
@@ -743,6 +759,22 @@ pub fn find_node(graph: &Graph, label: &str) -> Vec {
if term.is_empty() {
return Vec::new();
}
+ // Slash-normalize the query once (Windows `\` → `/`) so the basename (for
+ // the L1 file-node preference) and the full-path compare share one
+ // separator convention; otherwise `src\foo.rs` resolves the file but its
+ // basename keeps the backslash and misses the L1 preference (#1503).
+ let query_norm = strip_diacritics(label).to_lowercase().replace('\\', "/");
+ let query_basename = Path::new(&query_norm)
+ .file_name()
+ .and_then(|n| n.to_str())
+ .unwrap_or(&query_norm)
+ .to_string();
+ // Slash-normalized full path of the query, for exact source-path matching.
+ // Trailing separators are trimmed so a path query keeps matching the file
+ // (parity with the old tokenized compare, which dropped them) (#1503).
+ let query_path = query_norm.trim_end_matches('/').to_string();
+ let mut source_exact: Vec = Vec::new();
+ let mut preferred: Vec = Vec::new();
let mut exact: Vec = Vec::new();
let mut prefix: Vec = Vec::new();
let mut substring: Vec = Vec::new();
@@ -753,7 +785,28 @@ pub fn find_node(graph: &Graph, label: &str) -> Vec {
let node_term = search_tokens(&get_norm_label(attrs)).join(" ");
// `search_tokens` already lowercases, so pass `nid` directly.
let nid_term = search_tokens(nid).join(" ");
- if term == node_term || term == nid_term {
+ // Match the source-file path on its slash-normalized full form, NOT
+ // tokenized. graphify-py compares tokenized source paths (serve.py
+ // `source_tokens`), which collapses distinct paths to the same tokens
+ // (`src/foo/bar.py` and `src/foo_bar.py` both → "src foo bar py"), so a
+ // path query could land on the wrong file. The full-path compare avoids
+ // that; tokenized matching stays for label/id below (divergence, #1503).
+ let source_path = strip_diacritics(
+ attrs
+ .get("source_file")
+ .and_then(Value::as_str)
+ .unwrap_or(""),
+ )
+ .to_lowercase()
+ .replace('\\', "/");
+ if !source_path.is_empty() && query_path == source_path {
+ source_exact.push(nid.clone());
+ if attrs.get("source_location").and_then(Value::as_str) == Some("L1")
+ && get_norm_label(attrs) == query_basename
+ {
+ preferred.push(nid.clone());
+ }
+ } else if term == node_term || term == nid_term {
exact.push(nid.clone());
} else if node_term.starts_with(&term) || nid_term.starts_with(&term) {
prefix.push(nid.clone());
@@ -761,9 +814,22 @@ pub fn find_node(graph: &Graph, label: &str) -> Vec {
substring.push(nid.clone());
}
}
- exact.extend(prefix);
- exact.extend(substring);
- exact
+
+ if let [only] = preferred.as_slice() {
+ let mut reordered = vec![only.clone()];
+ reordered.extend(
+ source_exact
+ .iter()
+ .filter(|n| n.as_str() != only.as_str())
+ .cloned(),
+ );
+ source_exact = reordered;
+ }
+
+ source_exact.extend(exact);
+ source_exact.extend(prefix);
+ source_exact.extend(substring);
+ source_exact
}
// ── Shortest path ─────────────────────────────────────────────────────────────
diff --git a/crates/graphify-serve/tests/parity.rs b/crates/graphify-serve/tests/parity.rs
index 4b14376..fc82e9b 100644
--- a/crates/graphify-serve/tests/parity.rs
+++ b/crates/graphify-serve/tests/parity.rs
@@ -277,6 +277,61 @@ fn test_find_node_matches_full_punctuated_unicode_label() {
);
}
+#[test]
+fn test_find_node_source_file_path_prefers_file_level_node() {
+ // #1503: a source-file path query floats the L1 file node ahead of the
+ // symbols that share the file. `build_from_json` re-keys non-AST nodes to
+ // their full repo-relative path id (#1504): example_route ->
+ // app_api_example_route.
+ let g = build_from_json(
+ json!({
+ "nodes": [
+ {"id": "example_route_get", "label": "GET()",
+ "source_file": "app/api/example/route.ts", "source_location": "L42"},
+ {"id": "example_route", "label": "route.ts",
+ "source_file": "app/api/example/route.ts", "source_location": "L1"},
+ ],
+ "edges": [],
+ }),
+ false,
+ None,
+ )
+ .expect("make graph");
+ let matches = find_node(&g, "app/api/example/route.ts");
+ assert_eq!(
+ matches.first().map(String::as_str),
+ Some("app_api_example_route")
+ );
+ assert!(matches.iter().any(|m| m == "app_api_example_route_get"));
+}
+
+#[test]
+fn test_find_node_source_file_path_backslash_prefers_file_level_node() {
+ // #1503: a Windows-style backslash path query must behave like its
+ // forward-slash twin — the basename is derived from slash-normalized
+ // separators, so the L1 file node still floats ahead of its symbols.
+ let g = build_from_json(
+ json!({
+ "nodes": [
+ {"id": "example_route_get", "label": "GET()",
+ "source_file": "app/api/example/route.ts", "source_location": "L42"},
+ {"id": "example_route", "label": "route.ts",
+ "source_file": "app/api/example/route.ts", "source_location": "L1"},
+ ],
+ "edges": [],
+ }),
+ false,
+ None,
+ )
+ .expect("make graph");
+ let matches = find_node(&g, "app\\api\\example\\route.ts");
+ assert_eq!(
+ matches.first().map(String::as_str),
+ Some("app_api_example_route")
+ );
+ assert!(matches.iter().any(|m| m == "app_api_example_route_get"));
+}
+
#[test]
fn test_query_terms_strips_search_punctuation() {
assert_eq!(
diff --git a/crates/graphify-wiki/src/generate.rs b/crates/graphify-wiki/src/generate.rs
index 88b589e..614bbb9 100644
--- a/crates/graphify-wiki/src/generate.rs
+++ b/crates/graphify-wiki/src/generate.rs
@@ -3,7 +3,7 @@
use std::collections::HashMap;
use std::io::Write as _;
-use std::path::{Path, PathBuf};
+use std::path::Path;
use indexmap::{IndexMap, IndexSet};
@@ -67,27 +67,71 @@ pub fn to_wiki(
.collect();
let deg_map = build_degree_map(graph);
- let mut count = 0usize;
+ // First pass: assign every article its slug before rendering any body, so the
+ // bodies can link to one another via the resolver (#1444). A link's target is
+ // the on-disk slug, which differs from the label, so it must be known up front.
let mut used_slugs: IndexSet = IndexSet::new();
+ let mut resolver: HashMap = HashMap::new();
+ resolver.insert("index".to_string(), "index".to_string());
+ // Parity dispute (CodeRabbit): `index` is reserved in `resolver` only, NOT in
+ // `used_slugs` — matching graphify-py exactly (wiki.py: `resolver = {"index":
+ // "index"}` with an empty `used_slugs`). An article literally named "index"
+ // reuses the slug in both implementations; reserving it here would diverge
+ // from byte-identical wiki output, so we keep graphify-py's behaviour.
+
+ let mut community_slugs: IndexMap = IndexMap::new();
+ for &cid in filtered.keys() {
+ let label = labels
+ .get(&cid)
+ .cloned()
+ .unwrap_or_else(|| format!("Community {cid}"));
+ let slug = make_unique_slug(&safe_filename(&label), &mut used_slugs);
+ community_slugs.insert(cid, slug.clone());
+ // Parity dispute (CodeRabbit): the resolver is keyed by display label,
+ // mirroring graphify-py `resolver.setdefault(label, slug)`. Duplicate
+ // titles collapse to the first slug in both; keying by node id instead
+ // would diverge from graphify-py's byte-identical links.
+ resolver.entry(label).or_insert(slug);
+ }
+ let mut god_articles: Vec<(String, String)> = Vec::new(); // (node_id, slug)
+ for node_data in god_nodes_data {
+ if graph.contains_node(&node_data.id) {
+ let slug = make_unique_slug(&safe_filename(&node_data.label), &mut used_slugs);
+ resolver
+ .entry(node_data.label.clone())
+ .or_insert(slug.clone());
+ god_articles.push((node_data.id.clone(), slug));
+ }
+ }
+
+ // Second pass: render and write each article with the full resolver in hand.
+ let mut count = 0usize;
let wiki_ctx = WikiCtx {
graph,
labels,
node_community: &node_community,
deg_map: °_map,
+ resolver: &resolver,
output_dir,
};
- count += write_community_articles(&wiki_ctx, &filtered, cohesion, &mut used_slugs)?;
- count += write_god_node_articles(&wiki_ctx, god_nodes_data, &mut used_slugs)?;
+ count += write_community_articles(&wiki_ctx, &filtered, cohesion, &community_slugs)?;
+ count += write_god_node_articles(&wiki_ctx, &god_articles)?;
+ // Parity dispute (CodeRabbit): `index_md` gets the FULL `god_nodes_data`, not the
+ // filtered `god_articles` set — matching graphify-py `wiki.py:333`. A god
+ // node absent from the graph never entered `resolver` above, so `md_link`
+ // renders it as plain text, NOT a broken link (parity with `_md_link`,
+ // wiki.py:45-47). Filtering here would drop those plain-text catalog
+ // entries and diverge from byte-identical `index.md` output.
let index = index_md(
&filtered,
labels,
god_nodes_data,
graph.node_count(),
graph.edge_count(),
+ &resolver,
);
- let index_path: PathBuf = output_dir.join("index.md");
- std::fs::write(&index_path, index.as_bytes())?;
+ std::fs::write(output_dir.join("index.md"), index.as_bytes())?;
Ok(count)
}
@@ -139,15 +183,18 @@ fn clear_existing_md_files(output_dir: &Path) -> Result<(), WikiError> {
Ok(())
}
-/// Generate a fresh, deduplicated filename slug.
+/// Generate a fresh, deduplicated filename slug, folding case in the collision
+/// check so two labels differing only by case (`Parser` vs `parser`) get distinct
+/// files on case-insensitive filesystems while keeping the original-case slug
+/// (#1453).
fn make_unique_slug(base: &str, used_slugs: &mut IndexSet) -> String {
let mut slug = base.to_string();
let mut n = 2usize;
- while used_slugs.contains(&slug) {
+ while used_slugs.contains(&slug.to_lowercase()) {
slug = format!("{base}_{n}");
n += 1;
}
- used_slugs.insert(slug.clone());
+ used_slugs.insert(slug.to_lowercase());
slug
}
@@ -157,6 +204,7 @@ struct WikiCtx<'a> {
labels: &'a IndexMap,
node_community: &'a HashMap,
deg_map: &'a HashMap<&'a str, usize>,
+ resolver: &'a HashMap,
output_dir: &'a Path,
}
@@ -164,7 +212,7 @@ fn write_community_articles(
ctx: &WikiCtx<'_>,
filtered: &IndexMap>,
cohesion: &IndexMap,
- used_slugs: &mut IndexSet,
+ community_slugs: &IndexMap,
) -> Result {
let mut count = 0usize;
for (&cid, nodes) in filtered {
@@ -182,10 +230,13 @@ fn write_community_articles(
cohesion: cohesion.get(&cid).copied(),
node_community: ctx.node_community,
deg_map: ctx.deg_map,
+ resolver: ctx.resolver,
});
- let slug = make_unique_slug(&safe_filename(&label), used_slugs);
- let path: PathBuf = ctx.output_dir.join(format!("{slug}.md"));
- std::fs::write(&path, article.as_bytes())?;
+ let slug = &community_slugs[&cid];
+ std::fs::write(
+ ctx.output_dir.join(format!("{slug}.md")),
+ article.as_bytes(),
+ )?;
count += 1;
}
Ok(count)
@@ -193,24 +244,21 @@ fn write_community_articles(
fn write_god_node_articles(
ctx: &WikiCtx<'_>,
- god_nodes_data: &[GodNodeData],
- used_slugs: &mut IndexSet,
+ god_articles: &[(String, String)],
) -> Result {
- let mut count = 0usize;
- for node_data in god_nodes_data {
- if ctx.graph.contains_node(&node_data.id) {
- let article = god_node_article(
- ctx.graph,
- &node_data.id,
- ctx.labels,
- ctx.node_community,
- ctx.deg_map,
- );
- let slug = make_unique_slug(&safe_filename(&node_data.label), used_slugs);
- let path: PathBuf = ctx.output_dir.join(format!("{slug}.md"));
- std::fs::write(&path, article.as_bytes())?;
- count += 1;
- }
+ for (nid, slug) in god_articles {
+ let article = god_node_article(
+ ctx.graph,
+ nid,
+ ctx.labels,
+ ctx.node_community,
+ ctx.deg_map,
+ ctx.resolver,
+ );
+ std::fs::write(
+ ctx.output_dir.join(format!("{slug}.md")),
+ article.as_bytes(),
+ )?;
}
- Ok(count)
+ Ok(god_articles.len())
}
diff --git a/crates/graphify-wiki/src/render.rs b/crates/graphify-wiki/src/render.rs
index 78df87d..1098311 100644
--- a/crates/graphify-wiki/src/render.rs
+++ b/crates/graphify-wiki/src/render.rs
@@ -8,7 +8,7 @@ use indexmap::{IndexMap, IndexSet};
use graphify_build::Graph;
use crate::types::GodNodeData;
-use crate::util::{audit_trail_lines, cross_community_links, neighbors_of};
+use crate::util::{audit_trail_lines, cross_community_links, md_link, neighbors_of};
/// Read-only inputs for [`community_article`].
pub(crate) struct CommunityArticleArgs<'a> {
@@ -20,6 +20,7 @@ pub(crate) struct CommunityArticleArgs<'a> {
pub cohesion: Option,
pub node_community: &'a HashMap,
pub deg_map: &'a HashMap<&'a str, usize>,
+ pub resolver: &'a HashMap,
}
/// Render one community article as a Markdown string.
@@ -44,6 +45,7 @@ pub(crate) fn community_article(args: &CommunityArticleArgs<'_>) -> String {
cohesion,
node_community,
deg_map,
+ resolver,
} = *args;
let mut sorted_nodes: Vec<&String> = nodes.iter().collect();
sorted_nodes.sort_by(|a, b| {
@@ -129,7 +131,10 @@ pub(crate) fn community_article(args: &CommunityArticleArgs<'_>) -> String {
lines.push("- No strong cross-community connections detected".to_string());
} else {
for (other_label, count) in cross.iter().take(12) {
- lines.push(format!("- [[{other_label}]] ({count} shared connections)"));
+ lines.push(format!(
+ "- {} ({count} shared connections)",
+ md_link(other_label, resolver)
+ ));
}
}
lines.push(String::new());
@@ -150,7 +155,10 @@ pub(crate) fn community_article(args: &CommunityArticleArgs<'_>) -> String {
lines.push("---".to_string());
lines.push(String::new());
- lines.push("*Part of the graphify knowledge wiki. See [[index]] to navigate.*".to_string());
+ lines.push(format!(
+ "*Part of the graphify knowledge wiki. See {} to navigate.*",
+ md_link("index", resolver)
+ ));
lines.join("\n")
}
@@ -167,6 +175,7 @@ pub(crate) fn god_node_article(
labels: &IndexMap,
node_community: &HashMap,
deg_map: &HashMap<&str, usize>,
+ resolver: &HashMap,
) -> String {
let attrs = graph.node_data(nid);
let node_label = attrs
@@ -192,7 +201,7 @@ pub(crate) fn god_node_article(
lines.push(String::new());
if let Some(ref cn) = community_name {
- lines.push(format!("**Community:** [[{cn}]]"));
+ lines.push(format!("**Community:** {}", md_link(cn, resolver)));
lines.push(String::new());
}
@@ -228,7 +237,7 @@ pub(crate) fn god_node_article(
by_relation
.entry(rel)
.or_default()
- .push(format!("[[{neighbor_label}]]{conf_str}"));
+ .push(format!("{}{conf_str}", md_link(neighbor_label, resolver)));
}
lines.push("## Connections by Relation".to_string());
@@ -245,7 +254,10 @@ pub(crate) fn god_node_article(
lines.push("---".to_string());
lines.push(String::new());
- lines.push("*Part of the graphify knowledge wiki. See [[index]] to navigate.*".to_string());
+ lines.push(format!(
+ "*Part of the graphify knowledge wiki. See {} to navigate.*",
+ md_link("index", resolver)
+ ));
lines.join("\n")
}
@@ -262,6 +274,7 @@ pub(crate) fn index_md(
god_nodes_data: &[GodNodeData],
total_nodes: usize,
total_edges: usize,
+ resolver: &HashMap,
) -> String {
let mut lines: Vec = vec![
"# Knowledge Graph Index".to_string(),
@@ -288,7 +301,11 @@ pub(crate) fn index_md(
.get(&cid)
.cloned()
.unwrap_or_else(|| format!("Community {cid}"));
- lines.push(format!("- [[{label}]] — {} nodes", nodes.len()));
+ lines.push(format!(
+ "- {} — {} nodes",
+ md_link(&label, resolver),
+ nodes.len()
+ ));
}
lines.push(String::new());
@@ -298,8 +315,9 @@ pub(crate) fn index_md(
lines.push(String::new());
for node in god_nodes_data {
lines.push(format!(
- "- [[{}]] — {} connections",
- node.label, node.degree
+ "- {} — {} connections",
+ md_link(&node.label, resolver),
+ node.degree
));
}
lines.push(String::new());
diff --git a/crates/graphify-wiki/src/util.rs b/crates/graphify-wiki/src/util.rs
index 3ce3af4..f094d17 100644
--- a/crates/graphify-wiki/src/util.rs
+++ b/crates/graphify-wiki/src/util.rs
@@ -34,6 +34,40 @@ pub(crate) fn safe_filename(name: &str) -> String {
}
}
+/// Percent-encode a target URL the way Python's `urllib.parse.quote` does (its
+/// default safe set is `/` plus unreserved chars), so spaces, `&`, parentheses,
+/// and `#` survive intact in every `CommonMark` renderer (GitHub, GitLab, VS
+/// Code preview, a plain browser) and Obsidian alike.
+#[must_use]
+pub(crate) fn percent_encode(s: &str) -> String {
+ let mut out = String::with_capacity(s.len());
+ for b in s.bytes() {
+ if b.is_ascii_alphanumeric() || matches!(b, b'_' | b'.' | b'-' | b'~' | b'/') {
+ out.push(b as char);
+ } else {
+ const HEX: &[u8; 16] = b"0123456789ABCDEF";
+ out.push('%');
+ out.push(HEX[(b >> 4) as usize] as char);
+ out.push(HEX[(b & 0x0f) as usize] as char);
+ }
+ }
+ out
+}
+
+/// Render a link to another wiki article as a portable relative markdown link
+/// `[text](slug.md)` (URL-encoded target), or plain escaped text when the label
+/// has no article. Mirrors Python `_md_link` (#1444): the old `[[wikilink]]`
+/// form only resolved inside Obsidian, because the on-disk filename (the slug)
+/// differs from the label.
+#[must_use]
+pub(crate) fn md_link(label: &str, resolver: &HashMap) -> String {
+ let text = label.replace('[', "\\[").replace(']', "\\]");
+ match resolver.get(label) {
+ None => text,
+ Some(slug) => format!("[{text}]({})", percent_encode(&format!("{slug}.md"))),
+ }
+}
+
/// Compute per-node degree (number of incident edges, undirected).
///
/// Self-loops contribute one to the source's degree only, matching the Python
diff --git a/crates/graphify-wiki/tests/parity.rs b/crates/graphify-wiki/tests/parity.rs
index b5a72cf..aced625 100644
--- a/crates/graphify-wiki/tests/parity.rs
+++ b/crates/graphify-wiki/tests/parity.rs
@@ -1,7 +1,7 @@
//! Parity tests against `graphify-py/tests/test_wiki.py`.
-#![allow(clippy::expect_used)]
+#![allow(clippy::expect_used, clippy::unwrap_used)]
-use graphify_build::{Graph, GraphKind};
+use graphify_build::{Graph, GraphKind, build_from_json};
use graphify_wiki::{GodNodeData, to_wiki};
use indexmap::IndexMap;
use serde_json::Value;
@@ -190,8 +190,8 @@ fn test_index_links_all_communities() {
let labels = labels();
to_wiki(&g, &communities(), dir.path(), Some(&labels), None, None).expect("test invariant");
let index = std::fs::read_to_string(dir.path().join("index.md")).expect("test invariant");
- assert!(index.contains("[[Parsing Layer]]"));
- assert!(index.contains("[[Rendering Layer]]"));
+ assert!(index.contains("[Parsing Layer](Parsing_Layer.md)"));
+ assert!(index.contains("[Rendering Layer](Rendering_Layer.md)"));
}
#[test]
@@ -210,7 +210,7 @@ fn test_index_lists_god_nodes() {
)
.expect("test invariant");
let index = std::fs::read_to_string(dir.path().join("index.md")).expect("test invariant");
- assert!(index.contains("[[parse]]"));
+ assert!(index.contains("[parse](parse.md)"));
assert!(index.contains("2 connections"));
}
@@ -223,7 +223,7 @@ fn test_community_article_has_cross_links() {
let parsing =
std::fs::read_to_string(dir.path().join("Parsing_Layer.md")).expect("test invariant");
// n1 (parsing) references n3 (rendering) → cross-community link
- assert!(parsing.contains("[[Rendering Layer]]"));
+ assert!(parsing.contains("[Rendering Layer](Rendering_Layer.md)"));
}
#[test]
@@ -274,7 +274,11 @@ fn test_god_node_article_has_connections() {
)
.expect("test invariant");
let article = std::fs::read_to_string(dir.path().join("parse.md")).expect("test invariant");
- assert!(article.contains("[[validate]]") || article.contains("[[render]]"));
+ // parse's neighbours (validate, render) have no article, so they show as
+ // plain text, not links.
+ assert!(article.contains("validate") && article.contains("render"));
+ assert!(!article.contains("[["));
+ assert!(!article.contains("](validate.md)") && !article.contains("](render.md)"));
}
#[test]
@@ -293,7 +297,7 @@ fn test_god_node_article_links_community() {
)
.expect("test invariant");
let article = std::fs::read_to_string(dir.path().join("parse.md")).expect("test invariant");
- assert!(article.contains("[[Parsing Layer]]"));
+ assert!(article.contains("[Parsing Layer](Parsing_Layer.md)"));
}
#[test]
@@ -336,7 +340,7 @@ fn test_article_navigation_footer() {
to_wiki(&g, &communities(), dir.path(), Some(&labels), None, None).expect("test invariant");
let article =
std::fs::read_to_string(dir.path().join("Parsing_Layer.md")).expect("test invariant");
- assert!(article.contains("[[index]]"));
+ assert!(article.contains("[index](index.md)"));
}
#[test]
@@ -412,7 +416,7 @@ fn test_cross_community_links_without_node_community_attrs() {
to_wiki(&g, &comms, dir.path(), Some(&lbls), None, None).expect("test invariant");
let article = std::fs::read_to_string(dir.path().join("Parsing.md")).expect("test invariant");
- assert!(article.contains("[[Rendering]]"));
+ assert!(article.contains("[Rendering](Rendering.md)"));
}
#[test]
@@ -456,7 +460,7 @@ fn test_god_node_article_community_without_node_attr() {
to_wiki(&g, &comms, dir.path(), Some(&lbls), None, Some(&gods)).expect("test invariant");
let article = std::fs::read_to_string(dir.path().join("parse.md")).expect("test invariant");
- assert!(article.contains("[[Core Logic]]"));
+ assert!(article.contains("[Core Logic](Core_Logic.md)"));
}
#[test]
@@ -564,3 +568,272 @@ fn test_community_article_handles_null_source_file() {
.expect("community article must exist");
assert!(article.contains("parse") || article.contains("validate"));
}
+
+// ── #1444 portable links + #1453 case-fold slug ──────────────────────────────
+
+/// Build a small graph from `(id, label, source_file)` nodes and
+/// `(src, tgt, relation, confidence)` edges.
+fn graph_from(nodes: &[(&str, &str, &str)], edges: &[(&str, &str, &str, &str)]) -> Graph {
+ let json = serde_json::json!({
+ "nodes": nodes.iter().map(|(id, label, sf)| serde_json::json!({
+ "id": id, "label": label, "file_type": "code", "source_file": sf})).collect::>(),
+ "edges": edges.iter().map(|(s, t, r, c)| serde_json::json!({
+ "source": s, "target": t, "relation": r, "confidence": c, "weight": 1.0,
+ "source_file": "a.py"})).collect::>(),
+ });
+ build_from_json(json, false, None).expect("build")
+}
+
+fn percent_decode(s: &str) -> String {
+ let bytes = s.as_bytes();
+ let mut out: Vec = Vec::with_capacity(bytes.len());
+ let mut i = 0;
+ while i < bytes.len() {
+ if bytes[i] == b'%'
+ && i + 2 < bytes.len()
+ && let Ok(b) = u8::from_str_radix(&s[i + 1..i + 3], 16)
+ {
+ out.push(b);
+ i += 3;
+ } else {
+ out.push(bytes[i]);
+ i += 1;
+ }
+ }
+ String::from_utf8_lossy(&out).into_owned()
+}
+
+/// `(display, decoded_target)` for each inline markdown link, skipping external
+/// URLs. Simple labels only (no escaped brackets), matching Python `_inline_links`.
+fn inline_links(text: &str) -> Vec<(String, String)> {
+ let mut out = Vec::new();
+ let mut rest = text;
+ while let Some(open) = rest.find('[') {
+ let after = &rest[open + 1..];
+ let Some(close_rel) = after.find("](") else {
+ break;
+ };
+ let display = &after[..close_rel];
+ let target_start = &after[close_rel + 2..];
+ let Some(paren) = target_start.find(')') else {
+ break;
+ };
+ let target = &target_start[..paren];
+ if !display.contains(']') && !target.contains("://") {
+ out.push((display.to_string(), percent_decode(target)));
+ }
+ rest = &target_start[paren + 1..];
+ }
+ out
+}
+
+fn md_articles(dir: &std::path::Path) -> Vec {
+ std::fs::read_dir(dir)
+ .expect("read_dir")
+ .flatten()
+ .filter_map(|e| {
+ let p = e.path();
+ (p.extension().and_then(|x| x.to_str()) == Some("md")
+ && p.file_name().and_then(|n| n.to_str()) != Some("index.md"))
+ .then(|| p.file_stem().unwrap().to_string_lossy().into_owned())
+ })
+ .collect()
+}
+
+#[test]
+fn test_to_wiki_case_only_distinct_labels_dont_overwrite() {
+ let g = graph_from(
+ &[("n1", "parse", "a.py"), ("n2", "render", "b.py")],
+ &[("n1", "n2", "calls", "EXTRACTED")],
+ );
+ let comms: IndexMap> =
+ IndexMap::from([(0, vec!["n1".to_string()]), (1, vec!["n2".to_string()])]);
+ let labels: IndexMap =
+ IndexMap::from([(0, "Parser".to_string()), (1, "parser".to_string())]);
+ let dir = tempdir().expect("tempdir");
+ let n = to_wiki(&g, &comms, dir.path(), Some(&labels), None, None).expect("wiki");
+ let articles = md_articles(dir.path());
+ assert_eq!(articles.len(), n);
+ assert_eq!(n, 2, "{articles:?}");
+ let lowered: std::collections::HashSet =
+ articles.iter().map(|s| s.to_lowercase()).collect();
+ assert_eq!(lowered.len(), articles.len(), "{articles:?}");
+}
+
+#[test]
+fn test_to_wiki_god_node_label_case_collides_with_community() {
+ let g = graph_from(
+ &[("n1", "parse", "a.py"), ("n2", "run", "b.py")],
+ &[("n1", "n2", "calls", "EXTRACTED")],
+ );
+ let comms: IndexMap> =
+ IndexMap::from([(0, vec!["n1".to_string(), "n2".to_string()])]);
+ let labels: IndexMap = IndexMap::from([(0, "Parser".to_string())]);
+ let gods = [GodNodeData {
+ id: "n1".to_string(),
+ label: "parser".to_string(),
+ degree: 1,
+ }];
+ let dir = tempdir().expect("tempdir");
+ let n = to_wiki(&g, &comms, dir.path(), Some(&labels), None, Some(&gods)).expect("wiki");
+ let articles = md_articles(dir.path());
+ assert_eq!(articles.len(), n);
+ assert_eq!(n, 2, "{articles:?}");
+ let lowered: std::collections::HashSet =
+ articles.iter().map(|s| s.to_lowercase()).collect();
+ assert_eq!(lowered.len(), articles.len(), "{articles:?}");
+}
+
+#[test]
+fn test_wiki_emits_no_obsidian_wikilinks() {
+ let g = make_graph();
+ let gods = god_nodes();
+ let dir = tempdir().expect("tempdir");
+ to_wiki(
+ &g,
+ &communities(),
+ dir.path(),
+ Some(&labels()),
+ Some(&cohesion()),
+ Some(&gods),
+ )
+ .expect("wiki");
+ for e in std::fs::read_dir(dir.path()).expect("read_dir").flatten() {
+ let p = e.path();
+ if p.extension().and_then(|x| x.to_str()) == Some("md") {
+ assert!(
+ !std::fs::read_to_string(&p).unwrap().contains("[["),
+ "{:?}",
+ p.file_name()
+ );
+ }
+ }
+}
+
+#[test]
+fn test_wiki_links_resolve_to_real_files() {
+ let g = make_graph();
+ let gods = god_nodes();
+ let dir = tempdir().expect("tempdir");
+ to_wiki(
+ &g,
+ &communities(),
+ dir.path(),
+ Some(&labels()),
+ Some(&cohesion()),
+ Some(&gods),
+ )
+ .expect("wiki");
+ let mut seen = false;
+ for e in std::fs::read_dir(dir.path()).expect("read_dir").flatten() {
+ let p = e.path();
+ if p.extension().and_then(|x| x.to_str()) != Some("md") {
+ continue;
+ }
+ for (display, target) in inline_links(&std::fs::read_to_string(&p).unwrap()) {
+ seen = true;
+ assert!(
+ dir.path().join(&target).exists(),
+ "[{display}] -> {target} is dead"
+ );
+ }
+ }
+ assert!(seen, "expected inline markdown links");
+}
+
+#[test]
+fn test_wiki_link_display_keeps_label_but_target_is_filename() {
+ let g = make_graph();
+ let dir = tempdir().expect("tempdir");
+ to_wiki(&g, &communities(), dir.path(), Some(&labels()), None, None).expect("wiki");
+ let index = std::fs::read_to_string(dir.path().join("index.md")).expect("index");
+ assert!(index.contains("[Parsing Layer](Parsing_Layer.md)"));
+ assert!(!index.contains("Parsing Layer.md")); // the broken Obsidian-only target
+}
+
+#[test]
+fn test_wiki_special_characters_in_label_resolve() {
+ let g = graph_from(
+ &[("n1", "a", "a.py"), ("n2", "b", "b.py")],
+ &[("n1", "n2", "references", "INFERRED")],
+ );
+ let comms: IndexMap> =
+ IndexMap::from([(0, vec!["n1".to_string()]), (1, vec!["n2".to_string()])]);
+ let labels: IndexMap =
+ IndexMap::from([(0, "C# & Auth (v2)".to_string()), (1, "Other".to_string())]);
+ let dir = tempdir().expect("tempdir");
+ to_wiki(&g, &comms, dir.path(), Some(&labels), None, None).expect("wiki");
+ let article = std::fs::read_to_string(dir.path().join("Other.md")).expect("Other");
+ let targets: Vec = inline_links(&article).into_iter().map(|(_, t)| t).collect();
+ assert!(
+ targets.contains(&"C#_&_Auth_(v2).md".to_string()),
+ "{targets:?}"
+ );
+ assert!(dir.path().join("C#_&_Auth_(v2).md").exists());
+ assert!(
+ article.contains("C%23_%26_Auth_%28v2%29.md"),
+ "raw target must be percent-encoded"
+ );
+}
+
+#[test]
+fn test_wiki_link_with_bracketed_label_resolves() {
+ let g = graph_from(
+ &[("n1", "a", "a.py"), ("n2", "b", "b.py")],
+ &[("n1", "n2", "references", "INFERRED")],
+ );
+ let comms: IndexMap> =
+ IndexMap::from([(0, vec!["n1".to_string()]), (1, vec!["n2".to_string()])]);
+ let labels: IndexMap =
+ IndexMap::from([(0, "Array[T] Models".to_string()), (1, "Other".to_string())]);
+ let dir = tempdir().expect("tempdir");
+ to_wiki(&g, &comms, dir.path(), Some(&labels), None, None).expect("wiki");
+ let article = std::fs::read_to_string(dir.path().join("Other.md")).expect("Other");
+ assert!(
+ article.contains(r"[Array\[T\] Models](Array%5BT%5D_Models.md)"),
+ "{article}"
+ );
+ assert!(dir.path().join("Array[T]_Models.md").exists());
+}
+
+#[test]
+fn test_wiki_links_to_nodes_without_articles_are_plain_text() {
+ let g = make_graph();
+ let gods = god_nodes();
+ let dir = tempdir().expect("tempdir");
+ to_wiki(
+ &g,
+ &communities(),
+ dir.path(),
+ Some(&labels()),
+ None,
+ Some(&gods),
+ )
+ .expect("wiki");
+ let article = std::fs::read_to_string(dir.path().join("parse.md")).expect("parse");
+ assert!(article.contains("- validate") && article.contains("- render"));
+ assert!(!article.contains("[[validate]]") && !article.contains("[[render]]"));
+ for (_, target) in inline_links(&article) {
+ assert!(target != "validate.md" && target != "render.md", "{target}");
+ }
+}
+
+#[test]
+fn test_wiki_links_use_collision_suffixed_slug() {
+ let g = graph_from(
+ &[("n1", "a", "a.py"), ("n2", "b", "b.py")],
+ &[("n1", "n2", "references", "INFERRED")],
+ );
+ let comms: IndexMap> =
+ IndexMap::from([(0, vec!["n1".to_string()]), (1, vec!["n2".to_string()])]);
+ let labels: IndexMap =
+ IndexMap::from([(0, "Parser".to_string()), (1, "parser".to_string())]);
+ let dir = tempdir().expect("tempdir");
+ to_wiki(&g, &comms, dir.path(), Some(&labels), None, None).expect("wiki");
+ let index = std::fs::read_to_string(dir.path().join("index.md")).expect("index");
+ let targets: Vec = inline_links(&index).into_iter().map(|(_, t)| t).collect();
+ assert!(targets.contains(&"parser_2.md".to_string()), "{targets:?}");
+ for t in &targets {
+ assert!(dir.path().join(t).exists(), "{t}");
+ }
+}
diff --git a/graphify-py b/graphify-py
index 6d3c959..92e682f 160000
--- a/graphify-py
+++ b/graphify-py
@@ -1 +1 @@
-Subproject commit 6d3c9594e364d12f7c5da6f4cd95a3592ab710e6
+Subproject commit 92e682f1de69a717785373fd8d84e113e400402a
diff --git a/src/cli/args.rs b/src/cli/args.rs
index d2b1166..a8f5f1d 100644
--- a/src/cli/args.rs
+++ b/src/cli/args.rs
@@ -132,12 +132,21 @@ pub(crate) enum Command {
/// Communities per LLM labeling call (#1390).
#[arg(long = "batch-size", default_value_t = 100)]
batch_size: usize,
+ /// Print per-stage wall-clock timings to stderr (#1490).
+ #[arg(long)]
+ timing: bool,
+ /// Only (re)name communities that are unnamed or hold a `Community N`
+ /// placeholder, preserving existing labels (#1481).
+ #[arg(long = "missing-only")]
+ missing_only: bool,
},
/// (Re)name communities with the configured LLM backend, regenerate report.
///
- /// Equivalent to `cluster-only` but always refreshes community names even
- /// when a `.graphify_labels.json` already exists.
+ /// Equivalent to `cluster-only` but refreshes community names even when a
+ /// `.graphify_labels.json` already exists — unless `--missing-only` is set,
+ /// which renames only unnamed or `Community N` placeholder communities and
+ /// preserves the rest.
Label {
path: PathBuf,
#[arg(long = "no-viz")]
@@ -162,6 +171,13 @@ pub(crate) enum Command {
/// Communities per LLM labeling call (#1390).
#[arg(long = "batch-size", default_value_t = 100)]
batch_size: usize,
+ /// Print per-stage wall-clock timings to stderr (#1490).
+ #[arg(long)]
+ timing: bool,
+ /// Only (re)name communities that are unnamed or hold a `Community N`
+ /// placeholder, preserving existing labels (#1481).
+ #[arg(long = "missing-only")]
+ missing_only: bool,
},
/// Manage custom LLM providers (`graphify provider `).
@@ -323,6 +339,9 @@ pub(crate) enum Command {
/// Also extract schema from a live Postgres database at this DSN.
#[arg(long, value_name = "DSN")]
postgres: Option,
+ /// Print per-stage wall-clock timings to stderr (#1490).
+ #[arg(long)]
+ timing: bool,
},
/// Export graph to various formats.
diff --git a/src/cli/cluster_only.rs b/src/cli/cluster_only.rs
index 8b845ae..25100e5 100644
--- a/src/cli/cluster_only.rs
+++ b/src/cli/cluster_only.rs
@@ -7,6 +7,9 @@ use crate::cli::{build_analysis, load_graph};
/// Community-labelling knobs for [`cmd_cluster_only`].
#[derive(Clone, Copy, Default)]
+// Each field is an independent CLI flag (one `--flag` apiece); grouping them
+// into enums would be artificial — this is the options-bag the lint exempts.
+#[allow(clippy::struct_excessive_bools)]
pub(crate) struct LabelOptions<'a> {
/// Keep `Community N` placeholders instead of LLM-naming (the `--no-label` flag).
pub no_label: bool,
@@ -20,6 +23,11 @@ pub(crate) struct LabelOptions<'a> {
pub max_concurrency: usize,
/// Communities per LLM labeling call (#1390).
pub batch_size: usize,
+ /// Print per-stage wall-clock timings to stderr (#1490).
+ pub timing: bool,
+ /// Only (re)name communities that are unnamed or hold a `Community N`
+ /// placeholder, preserving existing labels (#1481).
+ pub missing_only: bool,
}
/// Rerun community detection on an existing graph.json and regenerate the report.
@@ -41,6 +49,7 @@ pub(crate) fn cmd_cluster_only(
opts: LabelOptions<'_>,
) -> Result<()> {
let start = std::time::Instant::now();
+ let mut stages = super::timer::StageTimer::new(opts.timing);
let graph_path = graph.map_or_else(
|| path.join(crate::cli::graphify_out_dir()).join("graph.json"),
std::path::Path::to_path_buf,
@@ -52,6 +61,7 @@ pub(crate) fn cmd_cluster_only(
g.node_count(),
g.edge_count()
);
+ stages.mark("load");
let hub_desc = exclude_hubs
.map(|p| format!(", exclude-hubs={p}"))
@@ -81,6 +91,7 @@ pub(crate) fn cmd_cluster_only(
communities.len(),
cluster_start.elapsed().as_secs_f64()
);
+ stages.mark("cluster");
// Mirror the watch/update path (#822, #1028): map new community IDs back to
// the prior ones by node overlap so an existing .graphify_labels.json keeps
@@ -131,13 +142,15 @@ pub(crate) fn cmd_cluster_only(
let analysis_path = graph_path.with_file_name(".graphify_analysis.json");
std::fs::write(&analysis_path, serde_json::to_string_pretty(&analysis)?)?;
eprintln!(" wrote {}", analysis_path.display());
+ stages.mark("analyze");
// Resolve `.graphify_labels.json` so the HTML viz and downstream exports can
// find community labels. Three paths, checked in this order:
- // 1. labels file exists & not forced → load it (preserve user edits, fill
- // any gaps with placeholders). This runs whether or not `--no-label` is
- // set: an existing file already means no LLM call, so `--no-label` is a
- // harmless no-op here — crucially, it must NOT wipe hand-curated labels
+ // 1. labels file exists & not forced & we are NOT LLM-naming gaps — i.e.
+ // not `--missing-only`, OR `--no-label` (which forbids any LLM call,
+ // so `--no-label --missing-only` lands here too) → load it (preserve
+ // user edits, fill any gaps with placeholders). Crucially this must
+ // NOT wipe hand-curated labels
// to placeholders. A malformed/unreadable file is NOT overwritten — we
// warn and fall back to placeholders for this run so the file isn't
// silently clobbered (divergence from Python `__main__.py:2418-2448`,
@@ -148,44 +161,96 @@ pub(crate) fn cmd_cluster_only(
// to placeholders on no-backend/error.
let labels_path = graph_path.with_file_name(".graphify_labels.json");
let mut skip_label_write = false;
- let labels: indexmap::IndexMap = if labels_path.exists() && !opts.force_relabel {
- match read_existing_labels(&labels_path) {
- Ok(mut existing) => {
- for cid in communities.keys() {
+ let labels: indexmap::IndexMap =
+ if labels_path.exists() && !opts.force_relabel && (!opts.missing_only || opts.no_label) {
+ match read_existing_labels(&labels_path) {
+ Ok(mut existing) => {
+ for cid in communities.keys() {
+ existing
+ .entry(*cid)
+ .or_insert_with(|| format!("Community {cid}"));
+ }
existing
- .entry(*cid)
- .or_insert_with(|| format!("Community {cid}"));
}
- existing
- }
- Err(e) => {
- eprintln!(
- " warning: could not read {} ({e}); using placeholders and \
+ Err(e) => {
+ eprintln!(
+ " warning: could not read {} ({e}); using placeholders and \
leaving the existing file untouched",
- labels_path.display()
+ labels_path.display()
+ );
+ skip_label_write = true;
+ graphify_llm::placeholder_community_labels(&communities)
+ }
+ }
+ } else if opts.no_label && !opts.force_relabel {
+ graphify_llm::placeholder_community_labels(&communities)
+ } else if opts.missing_only
+ && labels_path.exists()
+ && read_existing_labels(&labels_path).is_err()
+ {
+ // Malformed-but-present labels file under `--missing-only`: preserve it
+ // (don't relabel + overwrite), matching the non-`--missing-only` path
+ // above. Degrade to placeholders for this run; the file is left intact.
+ eprintln!(
+ " warning: could not read {} for --missing-only; using \
+ placeholders and leaving the existing file untouched",
+ labels_path.display()
+ );
+ skip_label_write = true;
+ graphify_llm::placeholder_community_labels(&communities)
+ } else {
+ // LLM community naming (#1097). With `--missing-only` (#1481), load any
+ // existing labels and name only the communities that are unnamed or hold
+ // a `Community N` placeholder, preserving the rest.
+ let existing: indexmap::IndexMap = if opts.missing_only {
+ read_existing_labels(&labels_path).unwrap_or_default()
+ } else {
+ indexmap::IndexMap::new()
+ };
+ let to_label: indexmap::IndexMap> = if opts.missing_only {
+ communities
+ .iter()
+ .filter(|(cid, _)| {
+ existing
+ .get(*cid)
+ .is_none_or(|name| is_placeholder_label(name))
+ })
+ .map(|(&cid, members)| (cid, members.clone()))
+ .collect()
+ } else {
+ communities.clone()
+ };
+ if to_label.is_empty() {
+ eprintln!(" all communities already named (--missing-only)");
+ existing
+ } else {
+ eprintln!("Labeling communities...");
+ let node_labels = node_label_map(&g);
+ let gods = god_node_ids(&g);
+ let (mut labels, _source) = graphify_llm::generate_community_labels(
+ &to_label,
+ &node_labels,
+ &gods,
+ opts.backend,
+ opts.model,
+ false, // quiet
+ opts.max_concurrency,
+ opts.batch_size,
);
- skip_label_write = true;
- graphify_llm::placeholder_community_labels(&communities)
+ // Keep existing good labels for communities we skipped, then backfill
+ // any still-missing community with a placeholder.
+ for (cid, name) in existing {
+ labels.entry(cid).or_insert(name);
+ }
+ for cid in communities.keys() {
+ labels
+ .entry(*cid)
+ .or_insert_with(|| format!("Community {cid}"));
+ }
+ labels
}
- }
- } else if opts.no_label && !opts.force_relabel {
- graphify_llm::placeholder_community_labels(&communities)
- } else {
- eprintln!("Labeling communities...");
- let node_labels = node_label_map(&g);
- let gods = god_node_ids(&g);
- let (labels, _source) = graphify_llm::generate_community_labels(
- &communities,
- &node_labels,
- &gods,
- opts.backend,
- opts.model,
- false, // quiet
- opts.max_concurrency,
- opts.batch_size,
- );
- labels
- };
+ };
+ stages.mark("label");
// Refresh graph.json so node community attrs match the new partition and
// carry the human community_name labels resolved above. Mirrors Python
@@ -233,10 +298,25 @@ pub(crate) fn cmd_cluster_only(
}
}
}
+
+ // Mark `export` after the HTML render so the stage spans it, matching
+ // graphify-py `__main__.py:3555` (`to_html(...)` then `stages.mark("export")`).
+ stages.mark("export");
+ stages.total();
eprintln!("done in {:.1}s", start.elapsed().as_secs_f64());
Ok(())
}
+/// True when a community label is absent or still a `Community N` placeholder,
+/// so `--missing-only` (#1481) should (re)name it.
+#[must_use]
+fn is_placeholder_label(name: &str) -> bool {
+ name.strip_prefix("Community ")
+ .map_or(name.is_empty(), |rest| {
+ !rest.is_empty() && rest.bytes().all(|b| b.is_ascii_digit())
+ })
+}
+
/// Read an existing `.graphify_labels.json` into a `cid → name` map.
///
/// Returns `Err` when the file is unreadable or is not a JSON object, so the
diff --git a/src/cli/dispatch.rs b/src/cli/dispatch.rs
index 3bee562..347a914 100644
--- a/src/cli/dispatch.rs
+++ b/src/cli/dispatch.rs
@@ -156,6 +156,8 @@ fn dispatch_cluster_only(cmd: Command) -> Result<()> {
model,
max_concurrency,
batch_size,
+ timing,
+ missing_only,
force,
) = match cmd {
Command::ClusterOnly {
@@ -170,6 +172,8 @@ fn dispatch_cluster_only(cmd: Command) -> Result<()> {
model,
max_concurrency,
batch_size,
+ timing,
+ missing_only,
} => (
path,
no_viz,
@@ -182,6 +186,8 @@ fn dispatch_cluster_only(cmd: Command) -> Result<()> {
model,
max_concurrency,
batch_size,
+ timing,
+ missing_only,
false,
),
Command::Label {
@@ -195,6 +201,8 @@ fn dispatch_cluster_only(cmd: Command) -> Result<()> {
model,
max_concurrency,
batch_size,
+ timing,
+ missing_only,
} => (
path,
no_viz,
@@ -207,6 +215,8 @@ fn dispatch_cluster_only(cmd: Command) -> Result<()> {
model,
max_concurrency,
batch_size,
+ timing,
+ missing_only,
true,
),
_ => unreachable!("dispatch_cluster_only invoked with wrong variant"),
@@ -225,6 +235,8 @@ fn dispatch_cluster_only(cmd: Command) -> Result<()> {
force_relabel: force,
max_concurrency,
batch_size,
+ timing,
+ missing_only,
},
)
}
@@ -336,6 +348,7 @@ fn dispatch_extract(cmd: Command) -> Result<()> {
dedup_llm,
cargo,
postgres,
+ timing,
} = cmd
else {
unreachable!("dispatch_extract invoked with wrong variant")
@@ -369,6 +382,7 @@ fn dispatch_extract(cmd: Command) -> Result<()> {
cargo,
postgres: postgres.as_deref(),
},
+ timing,
})
}
diff --git a/src/cli/extract.rs b/src/cli/extract.rs
index d577f28..8ed29b3 100644
--- a/src/cli/extract.rs
+++ b/src/cli/extract.rs
@@ -52,6 +52,8 @@ pub(crate) struct ExtractOptions<'a> {
pub cluster: ClusterOptions,
pub global: GlobalOptions<'a>,
pub introspect: IntrospectOptions<'a>,
+ /// Print per-stage wall-clock timings to stderr (#1490).
+ pub timing: bool,
}
/// Run the headless full extraction pipeline (AST + optional LLM semantic enrichment).
@@ -64,6 +66,11 @@ pub(crate) struct ExtractOptions<'a> {
/// `conceptually_related_to`, etc.) that the AST extractor cannot infer.
///
/// Ports `__main__.py:2397` (`elif cmd == "extract"`).
+// CLI entry point: linear orchestration (detect → AST → semantic → build →
+// cluster → write graph.json → analyze → HTML viz) reads clearer as one flow
+// than split helpers. graph.json is written before the analysis phase so the
+// core artifact always lands even if analysis is skipped (--no-cluster).
+#[allow(clippy::too_many_lines)]
pub(crate) fn cmd_extract(opts: ExtractOptions<'_>) -> Result<()> {
let ExtractOptions {
path,
@@ -74,6 +81,7 @@ pub(crate) fn cmd_extract(opts: ExtractOptions<'_>) -> Result<()> {
cluster,
global,
introspect,
+ timing,
} = opts;
let LlmOptions {
backend,
@@ -108,14 +116,17 @@ pub(crate) fn cmd_extract(opts: ExtractOptions<'_>) -> Result<()> {
report_deep_mode(deep_mode, effective_backend.is_some());
let start = std::time::Instant::now();
+ let mut stages = super::timer::StageTimer::new(timing);
let out_dir = out.map_or_else(
|| path.join(graphify_out_dir()),
std::path::Path::to_path_buf,
);
let detect = run_detect_phase(path, &out_dir, extra_excludes);
+ stages.mark("detect");
let files = collect_extract_files(path, &detect);
let extraction = run_ast_extract_phase(&files, path);
+ stages.mark("AST extract");
let cfg = SemanticConfig {
backend: effective_backend.as_deref(),
model,
@@ -129,6 +140,7 @@ pub(crate) fn cmd_extract(opts: ExtractOptions<'_>) -> Result<()> {
sem_input_tokens,
sem_output_tokens,
} = run_semantic_phase(path, &files, &extraction, &cfg)?;
+ stages.mark("semantic extract");
// Merge opt-in structural introspection (Cargo manifests / live PostgreSQL)
// into the AST+semantic node/edge set before the graph is built. Order
@@ -145,10 +157,13 @@ pub(crate) fn cmd_extract(opts: ExtractOptions<'_>) -> Result<()> {
effective_backend.as_deref(),
path,
)?;
+ stages.mark("build");
let graph_path = out_dir.join("graph.json");
let communities = run_cluster_phase(&graph, no_cluster, resolution, exclude_hubs)?;
+ stages.mark("cluster");
graphify_export::to_json(&graph, &communities, &graph_path, true, None, None)?;
eprintln!(" wrote {}", graph_path.display());
+ stages.mark("export");
persist_semantic_marker(&out_dir, sem_output_tokens)?;
if no_cluster {
@@ -162,11 +177,13 @@ pub(crate) fn cmd_extract(opts: ExtractOptions<'_>) -> Result<()> {
if global {
cmd_extract_global_add(&graph_path, as_tag, path);
}
+ stages.total();
eprintln!("done in {:.1}s", start.elapsed().as_secs_f64());
return Ok(());
}
run_analysis_phase(&graph, &communities, path, &out_dir)?;
+ stages.mark("analyze");
let labels = sync_labels_file(&out_dir, &communities)?;
render_html_viz(&graph, &communities, &out_dir, &labels);
@@ -180,6 +197,7 @@ pub(crate) fn cmd_extract(opts: ExtractOptions<'_>) -> Result<()> {
sem_output_tokens,
);
+ stages.total();
eprintln!("done in {:.1}s", start.elapsed().as_secs_f64());
Ok(())
}
diff --git a/src/cli/mod.rs b/src/cli/mod.rs
index b01ab59..091dfc1 100644
--- a/src/cli/mod.rs
+++ b/src/cli/mod.rs
@@ -25,6 +25,7 @@ pub(crate) mod query;
pub(crate) mod reflect;
pub(crate) mod save_result;
pub(crate) mod serve;
+pub(crate) mod timer;
pub(crate) mod tree;
pub(crate) mod validate;
pub(crate) mod watch;
@@ -82,6 +83,22 @@ pub(crate) fn load_graph(path: &std::path::Path) -> anyhow::Result Result<()> {
default_graph.exists().then_some(default_graph)
});
- if args.if_stale && graphify_reflect::lessons_fresh(&out_path, &memory_dir, graph.as_deref()) {
+ let graphs = graphify_reflect::GraphPaths {
+ graph: graph.as_deref(),
+ analysis: args.analysis.as_deref(),
+ labels: args.labels.as_deref(),
+ };
+
+ if args.if_stale && graphify_reflect::lessons_fresh(&out_path, &memory_dir, graphs) {
println!(
"Lessons already up to date -> {} (skipped; omit --if-stale to force)",
out_path.display()
@@ -57,11 +63,6 @@ pub(crate) fn cmd_reflect(args: ReflectArgs) -> Result<()> {
return Ok(());
}
- let graphs = graphify_reflect::GraphPaths {
- graph: graph.as_deref(),
- analysis: args.analysis.as_deref(),
- labels: args.labels.as_deref(),
- };
let (path, agg) = graphify_reflect::reflect(
&memory_dir,
&out_path,
diff --git a/src/cli/timer.rs b/src/cli/timer.rs
new file mode 100644
index 0000000..82f9ea2
--- /dev/null
+++ b/src/cli/timer.rs
@@ -0,0 +1,51 @@
+//! Per-stage wall-clock timing for `--timing` (#1490).
+//!
+//! Mirrors Python `_StageTimer` in `__main__.py`: monotonic, diagnostic-only.
+//! Emits `[graphify timing] : N.Ns` to stderr after each stage and a
+//! final total. Off by default, so normal output is byte-identical and the
+//! machine-read stdout / `graph.json` are untouched.
+
+use std::time::Instant;
+
+/// Tracks elapsed time between stage marks, printing to stderr when enabled.
+pub(crate) struct StageTimer {
+ enabled: bool,
+ start: Instant,
+ last: Instant,
+}
+
+impl StageTimer {
+ /// Create a timer; `enabled` gates all output (off → silent no-op).
+ #[must_use]
+ pub(crate) fn new(enabled: bool) -> Self {
+ let now = Instant::now();
+ Self {
+ enabled,
+ start: now,
+ last: now,
+ }
+ }
+
+ /// Print the elapsed time since the previous mark as `` and reset the
+ /// per-stage clock.
+ pub(crate) fn mark(&mut self, stage: &str) {
+ let now = Instant::now();
+ if self.enabled {
+ eprintln!(
+ "[graphify timing] {stage}: {:.1}s",
+ now.duration_since(self.last).as_secs_f64()
+ );
+ }
+ self.last = now;
+ }
+
+ /// Print the total elapsed time since construction.
+ pub(crate) fn total(&self) {
+ if self.enabled {
+ eprintln!(
+ "[graphify timing] total: {:.1}s",
+ self.start.elapsed().as_secs_f64()
+ );
+ }
+ }
+}
diff --git a/tests/cli.rs b/tests/cli.rs
index 1f10d6f..c0733f8 100644
--- a/tests/cli.rs
+++ b/tests/cli.rs
@@ -598,3 +598,79 @@ fn export_graphml_writes_file() {
.success();
assert!(dir.path().join("graph.graphml").exists());
}
+
+/// Ports `test_explain_cli.py::test_explain_source_file_path_prefers_file_level_node`
+/// (#1503): a source-file path resolves to the L1 file node, not a symbol in it.
+#[test]
+fn explain_source_file_path_prefers_file_level_node() -> Result<(), Box> {
+ let dir = tempfile::tempdir()?;
+ let graph_path = dir.path().join("graph.json");
+ let graph = r#"{
+ "directed": false, "multigraph": false, "graph": {},
+ "nodes": [
+ {"id": "example_route_get", "label": "GET()", "source_file": "app/api/example/route.ts", "source_location": "L42", "community": 0},
+ {"id": "example_route", "label": "route.ts", "source_file": "app/api/example/route.ts", "source_location": "L1", "community": 0}
+ ],
+ "links": [
+ {"source": "example_route", "target": "example_route_get", "relation": "contains", "confidence": "EXTRACTED"}
+ ]
+ }"#;
+ fs::write(&graph_path, graph)?;
+ let assert = cli()
+ .arg("explain")
+ .arg("app/api/example/route.ts")
+ .arg("--graph")
+ .arg(&graph_path)
+ .assert()
+ .success();
+ let stdout = String::from_utf8_lossy(&assert.get_output().stdout).into_owned();
+ assert!(stdout.contains("Node: route.ts"), "got: {stdout}");
+ // build_from_json re-keys the L1 file node to its full repo-relative path id
+ // (#1504): example_route -> app_api_example_route.
+ assert!(
+ stdout.contains("ID: app_api_example_route"),
+ "got: {stdout}"
+ );
+ assert!(
+ stdout.contains("Source: app/api/example/route.ts L1"),
+ "got: {stdout}"
+ );
+ assert!(!stdout.contains("Node: GET()"), "got: {stdout}");
+ Ok(())
+}
+
+/// Ports `test_affected_cli.py::test_affected_cli_source_file_path_uses_file_level_node`
+/// (#1503): `affected ` seeds the L1 file node and reports its dependants.
+#[test]
+fn affected_source_file_path_uses_file_level_node() -> Result<(), Box> {
+ let dir = tempfile::tempdir()?;
+ let graph_path = dir.path().join("graph.json");
+ let graph = r#"{
+ "directed": true, "multigraph": false, "graph": {},
+ "nodes": [
+ {"id": "example_route_get", "label": "GET()", "source_file": "app/api/example/route.ts", "source_location": "L42"},
+ {"id": "example_route", "label": "route.ts", "source_file": "app/api/example/route.ts", "source_location": "L1"},
+ {"id": "consumer", "label": "consumer.ts", "source_file": "app/consumer.ts", "source_location": "L1"}
+ ],
+ "links": [
+ {"source": "consumer", "target": "example_route", "relation": "imports_from", "context": "import", "confidence": "EXTRACTED"}
+ ]
+ }"#;
+ fs::write(&graph_path, graph)?;
+ let assert = cli()
+ .arg("affected")
+ .arg("app/api/example/route.ts")
+ .arg("--graph")
+ .arg(&graph_path)
+ .assert()
+ .success();
+ let stdout = String::from_utf8_lossy(&assert.get_output().stdout).into_owned();
+ assert!(
+ stdout.contains("Affected nodes for route.ts"),
+ "got: {stdout}"
+ );
+ assert!(stdout.contains("consumer.ts"), "got: {stdout}");
+ assert!(stdout.contains("imports_from"), "got: {stdout}");
+ assert!(!stdout.contains("No unique node match"), "got: {stdout}");
+ Ok(())
+}
diff --git a/tests/cli_commands.rs b/tests/cli_commands.rs
index 2d0131f..d02e7df 100644
--- a/tests/cli_commands.rs
+++ b/tests/cli_commands.rs
@@ -879,11 +879,102 @@ fn label_no_backend_keeps_placeholders() {
}
#[test]
-fn label_accepts_model_flag() {
+fn cluster_only_timing_emits_stage_lines() -> Result<(), Box> {
+ // #1490: `--timing` prints per-stage wall-clock lines plus a total to stderr.
+ let dir = tempfile::tempdir()?;
+ let out = dir.path().join("graphify-out");
+ fs::create_dir_all(&out)?;
+ let graph_path = out.join("graph.json");
+ write_graph_json(&graph_path);
+ cli_no_backend()
+ .arg("cluster-only")
+ .arg(dir.path())
+ .arg("--graph")
+ .arg(&graph_path)
+ .arg("--no-viz")
+ .arg("--timing")
+ .assert()
+ .success()
+ .stderr(contains("[graphify timing] label:").and(contains("total:")));
+ Ok(())
+}
+
+#[test]
+fn label_missing_only_preserves_existing_labels() -> Result<(), Box> {
+ // #1481: `--missing-only` keeps curated community names and only (re)names
+ // unnamed / `Community N` placeholders. With no backend the placeholder
+ // community stays a placeholder, but the hand-written name must survive.
+ let dir = tempfile::tempdir()?;
+ let out = dir.path().join("graphify-out");
+ fs::create_dir_all(&out)?;
+ let graph_path = out.join("graph.json");
+ write_graph_json(&graph_path);
+ fs::write(
+ out.join(".graphify_labels.json"),
+ r#"{"0":"Authentication","1":"Community 1"}"#,
+ )?;
+ cli_no_backend()
+ .arg("label")
+ .arg(dir.path())
+ .arg("--graph")
+ .arg(&graph_path)
+ .arg("--no-viz")
+ .arg("--missing-only")
+ .assert()
+ .success();
+ let labels: serde_json::Value =
+ serde_json::from_str(&fs::read_to_string(out.join(".graphify_labels.json"))?)?;
+ assert_eq!(
+ labels["0"].as_str(),
+ Some("Authentication"),
+ "community 0 must keep its curated label under --missing-only: {labels}"
+ );
+ Ok(())
+}
+
+#[test]
+fn cluster_only_no_label_missing_only_preserves_existing_labels()
+-> Result<(), Box> {
+ // Regression: `cluster-only --no-label --missing-only` must NOT wipe
+ // hand-curated labels. `--no-label` forbids any LLM call, so existing names
+ // are preserved (only true gaps fall back to placeholders). Previously the
+ // `--no-label` branch placeholdered every community, clobbering the curated
+ // file whenever `--missing-only` was also set.
+ let dir = tempfile::tempdir()?;
+ let out = dir.path().join("graphify-out");
+ fs::create_dir_all(&out)?;
+ let graph_path = out.join("graph.json");
+ write_graph_json(&graph_path);
+ fs::write(
+ out.join(".graphify_labels.json"),
+ r#"{"0":"Authentication","1":"Community 1"}"#,
+ )?;
+ cli_no_backend()
+ .arg("cluster-only")
+ .arg(dir.path())
+ .arg("--graph")
+ .arg(&graph_path)
+ .arg("--no-viz")
+ .arg("--no-label")
+ .arg("--missing-only")
+ .assert()
+ .success();
+ let labels: serde_json::Value =
+ serde_json::from_str(&fs::read_to_string(out.join(".graphify_labels.json"))?)?;
+ assert_eq!(
+ labels["0"].as_str(),
+ Some("Authentication"),
+ "community 0 must keep its curated label under --no-label --missing-only: {labels}"
+ );
+ Ok(())
+}
+
+#[test]
+fn label_accepts_model_flag() -> Result<(), Box> {
// `label --model` parses and threads through to the labeling path (#b304331).
// With no backend key the run still degrades to placeholders, proving the
// flag is accepted end-to-end without error.
- let dir = tempfile::tempdir().unwrap();
+ let dir = tempfile::tempdir()?;
write_python_project(dir.path());
cli_no_backend()
.arg("extract")
@@ -907,20 +998,20 @@ fn label_accepts_model_flag() {
dir.path()
.join("graphify-out")
.join(".graphify_labels.json"),
- )
- .unwrap();
+ )?;
assert!(
labels.contains("Community"),
"expected placeholder labels: {labels}"
);
+ Ok(())
}
#[test]
-fn label_accepts_concurrency_flags() {
+fn label_accepts_concurrency_flags() -> Result<(), Box> {
// #1390: `label --max-concurrency --batch-size` parse and thread through to
// the labeling path. With no backend the run degrades to placeholders,
// proving the flags are accepted end-to-end without error.
- let dir = tempfile::tempdir().unwrap();
+ let dir = tempfile::tempdir()?;
write_python_project(dir.path());
cli_no_backend()
.arg("extract")
@@ -939,6 +1030,7 @@ fn label_accepts_concurrency_flags() {
.arg("--no-viz")
.assert()
.success();
+ Ok(())
}
/// #1347/#1350: a no-op incremental `extract --no-cluster` re-run must leave