@chrisdudek/yg 2.2.0 → 2.3.1

package/README.md

@@ -51,6 +51,7 @@ yg build-context --node orders/order-service
 - `yg owner --file <path>` — Find which graph node owns a source file
 - `yg deps --node <path>` — Forward dependency tree and materialization order
 - `yg impact --node <path> [--simulate]` — Reverse dependencies and context impact
+- `yg select --task <description> [--limit <n>]` — Find graph nodes relevant to a task
 - `yg aspects` — List aspects with metadata (YAML output)
 - `yg flows` — List flows with metadata (YAML output)
 

package/dist/bin.js

@@ -4,7 +4,7 @@
 import { Command } from "commander";
 
 // src/cli/init.ts
-import { mkdir as mkdir2, writeFile as writeFile3, readdir as readdir2, readFile as readFile4, stat as stat2 } from "fs/promises";
+import { mkdir as mkdir2, writeFile as writeFile4, readdir as readdir2, readFile as readFile4, stat as stat2 } from "fs/promises";
 import path4 from "path";
 import { fileURLToPath } from "url";
 import { readFileSync } from "fs";
@@ -68,10 +68,10 @@ Yggdrasil is persistent semantic memory stored in \`.yggdrasil/\`. It maps the r
 
 \`\`\`
 BEFORE reading, researching, planning, OR modifying ANY mapped file:
-  0. Don't know which file or node to start from? If a semantic search
-     tool is available, search for your intent \u2014 the graph contains
-     responsibility, flow, and aspect files with rich natural-language
-     descriptions that match goal-oriented queries. Use the results
+  0. Don't know which file or node to start from? Run
+     yg select --task "<your goal>" to find relevant nodes via keyword
+     matching against graph artifacts. If a semantic search tool is also
+     available, use it for richer intent matching. Use the results
      to identify relevant nodes, then proceed to step 1.
   1. yg owner --file <path>
   2. Choose the right graph tool for your task:
@@ -147,7 +147,7 @@ What matters is the ACTION you are performing, not what instructed it. If the ac
 | "I'm brainstorming, not implementing" | Brainstorming about mapped code needs graph context |
 | "I'm only grepping for references" | Grep finds text; yg impact finds structural dependencies. Use both. |
 | "I'll use the graph later when I modify" | Graph-first means BEFORE reading, not before modifying |
-| "I'll grep the codebase to find where to start" | If semantic search is available, search by intent first \u2014 graph files are designed to match natural-language goals. Then \`yg owner\` on results. |
+| "I'll grep the codebase to find where to start" | Run \`yg select --task\` first \u2014 it matches your intent against graph artifacts. Then \`yg owner\` on results. |
 
 ### Failure States
 
@@ -454,6 +454,8 @@ yg build-context --node <path>      Assemble context package for this node.
 yg tree [--root <path>] [--depth N] Print graph structure.
 yg aspects                          List aspects with metadata (YAML output).
 yg flows                            List flows with metadata (YAML output).
+yg select --task <description> [--limit <n>]
+                                    Find graph nodes relevant to a task description.
 yg deps --node <path> [--depth N] [--type structural|event|all]
                                     Show dependencies.
 yg impact --node <path> --simulate  Simulate blast radius of a planned change.
@@ -723,7 +725,7 @@ function escapeRegex(s) {
 }
 
 // src/core/migrator.ts
-import { readFile as readFile2, access } from "fs/promises";
+import { readFile as readFile2, writeFile as writeFile2, access } from "fs/promises";
 import path2 from "path";
 import { parse as parseYaml } from "yaml";
 import { gt, valid, compare } from "semver";
@@ -761,9 +763,16 @@ async function runMigrations(currentVersion, migrations, yggRoot) {
   }
   return results;
 }
+async function updateConfigVersion(yggRoot, version) {
+  const configPath = path2.join(yggRoot, "yg-config.yaml");
+  const content = await readFile2(configPath, "utf-8");
+  const updated = content.match(/^version:\s/m) ? content.replace(/^version:\s.*$/m, `version: "${version}"`) : `version: "${version}"
+` + content;
+  await writeFile2(configPath, updated, "utf-8");
+}
 
 // src/migrations/to-2.0.0.ts
-import { readFile as readFile3, writeFile as writeFile2, rename, readdir, rm, stat } from "fs/promises";
+import { readFile as readFile3, writeFile as writeFile3, rename, readdir, rm, stat } from "fs/promises";
 import path3 from "path";
 import { parse as parseYaml2, stringify as stringifyYaml } from "yaml";
 var KNOWN_TYPE_DESCRIPTIONS = {
@@ -849,7 +858,7 @@ async function migrateTo2(yggRoot) {
   if (raw.quality) {
     newConfig.quality = raw.quality;
   }
-  await writeFile2(newConfigPath, stringifyYaml(newConfig, { lineWidth: 120 }), "utf-8");
+  await writeFile3(newConfigPath, stringifyYaml(newConfig, { lineWidth: 120 }), "utf-8");
   actions.push("Updated config: version, artifacts, removed stack/standards");
   const modelDir = path3.join(yggRoot, "model");
   if (await fileExists(modelDir)) {
@@ -913,8 +922,8 @@ async function migrateStackStandards(yggRoot, stack, standards, actions) {
   const rootNodeOldPath = path3.join(modelDir, "node.yaml");
   const hasRootNode = await fileExists(rootNodeYgPath) || await fileExists(rootNodeOldPath);
   if (!hasRootNode) {
-    await writeFile2(rootNodeYgPath, stringifyYaml({ name: "Root", type: "module" }), "utf-8");
-    await writeFile2(path3.join(modelDir, "responsibility.md"), "TBD\n", "utf-8");
+    await writeFile3(rootNodeYgPath, stringifyYaml({ name: "Root", type: "module" }), "utf-8");
+    await writeFile3(path3.join(modelDir, "responsibility.md"), "TBD\n", "utf-8");
     actions.push("Created root node in model/ for stack/standards migration");
   }
   const internalsPath = path3.join(modelDir, "internals.md");
@@ -925,7 +934,7 @@ async function migrateStackStandards(yggRoot, stack, standards, actions) {
   }
   const markerLine = MIGRATION_MARKER + "\n";
   const newContent = existingInternals ? existingInternals.trimEnd() + "\n\n" + markerLine + lines.join("\n") : markerLine + lines.join("\n");
-  await writeFile2(internalsPath, newContent, "utf-8");
+  await writeFile3(internalsPath, newContent, "utf-8");
   actions.push("Migrated stack/standards to model/internals.md");
 }
 async function renameFilesRecursively(dir, oldName, newName, actions) {
@@ -990,7 +999,7 @@ async function transformSingleNode(filePath, actions, warnings) {
     changed = true;
   }
   if (changed) {
-    await writeFile2(filePath, stringifyYaml(raw, { lineWidth: 120 }), "utf-8");
+    await writeFile3(filePath, stringifyYaml(raw, { lineWidth: 120 }), "utf-8");
     actions.push(`Transformed ${path3.basename(path3.dirname(filePath))}/yg-node.yaml`);
   }
 }
@@ -1026,7 +1035,7 @@ async function refreshSchemas(yggRoot) {
     for (const file of schemaFiles) {
       const srcPath = path4.join(graphSchemasDir, file);
       const content = await readFile4(srcPath, "utf-8");
-      await writeFile3(path4.join(schemasDir, file), content, "utf-8");
+      await writeFile4(path4.join(schemasDir, file), content, "utf-8");
     }
   } catch {
   }
@@ -1097,6 +1106,7 @@ function registerInitCommand(program2) {
         if (results.length > 0) {
           process.stdout.write("\n");
         }
+        await updateConfigVersion(yggRoot, cliVersion);
       }
       await refreshSchemas(yggRoot);
       const rulesPath2 = await installRulesForPlatform(projectRoot, platform);
@@ -1117,7 +1127,7 @@ function registerInitCommand(program2) {
       for (const file of schemaFiles) {
         const srcPath = path4.join(graphSchemasDir, file);
         const content = await readFile4(srcPath, "utf-8");
-        await writeFile3(path4.join(schemasDir, file), content, "utf-8");
+        await writeFile4(path4.join(schemasDir, file), content, "utf-8");
       }
     } catch (err) {
       process.stderr.write(
@@ -1125,8 +1135,8 @@ function registerInitCommand(program2) {
 `
       );
     }
-    await writeFile3(path4.join(yggRoot, "yg-config.yaml"), DEFAULT_CONFIG, "utf-8");
-    await writeFile3(path4.join(yggRoot, ".gitignore"), GITIGNORE_CONTENT, "utf-8");
+    await writeFile4(path4.join(yggRoot, "yg-config.yaml"), DEFAULT_CONFIG, "utf-8");
+    await writeFile4(path4.join(yggRoot, ".gitignore"), GITIGNORE_CONTENT, "utf-8");
     const rulesPath = await installRulesForPlatform(projectRoot, platform);
     process.stdout.write("\u2713 Yggdrasil initialized.\n\n");
     process.stdout.write("Created:\n");
@@ -2971,7 +2981,7 @@ ${errors.length} errors, ${warnings.length} warnings.
 import chalk2 from "chalk";
 
 // src/io/drift-state-store.ts
-import { readFile as readFile14, writeFile as writeFile4, stat as stat5, readdir as readdir6, mkdir as mkdir3, rm as rm2 } from "fs/promises";
+import { readFile as readFile14, writeFile as writeFile5, stat as stat5, readdir as readdir6, mkdir as mkdir3, rm as rm2 } from "fs/promises";
 import path12 from "path";
 import { parse as yamlParse } from "yaml";
 var DRIFT_STATE_DIR = ".drift-state";
@@ -3029,7 +3039,7 @@ async function writeNodeDriftState(yggRoot, nodePath, nodeState) {
   const filePath = nodeStatePath(yggRoot, nodePath);
   await mkdir3(path12.dirname(filePath), { recursive: true });
   const content = JSON.stringify(nodeState, null, 2) + "\n";
-  await writeFile4(filePath, content, "utf-8");
+  await writeFile5(filePath, content, "utf-8");
 }
 async function garbageCollectDriftState(yggRoot, validNodePaths) {
   const driftDir = path12.join(yggRoot, DRIFT_STATE_DIR);
@@ -3842,7 +3852,7 @@ function registerOwnerCommand(program2) {
 `);
         if (result.direct === false && result.mappingPath) {
           process.stdout.write(
-            `  Plik nie ma w\u0142asnego mapowania; kontekst pochodzi z nadrz\u0119dnego katalogu ${result.mappingPath}. U\u017Cyj: yg build-context --node ${result.nodePath}
+            `  File has no direct mapping; context comes from ancestor directory ${result.mappingPath}. Use: yg build-context --node ${result.nodePath}
 `
           );
         }
@@ -4510,6 +4520,199 @@ function registerPreflightCommand(program2) {
   });
 }
 
+// src/cli/select.ts
+import { stringify as yamlStringify3 } from "yaml";
+
+// src/utils/tokenizer.ts
+var STOP_WORDS = /* @__PURE__ */ new Set([
+  "a",
+  "an",
+  "the",
+  "is",
+  "are",
+  "was",
+  "were",
+  "be",
+  "been",
+  "being",
+  "have",
+  "has",
+  "had",
+  "do",
+  "does",
+  "did",
+  "will",
+  "would",
+  "shall",
+  "should",
+  "may",
+  "might",
+  "must",
+  "can",
+  "could",
+  "to",
+  "of",
+  "in",
+  "for",
+  "on",
+  "with",
+  "at",
+  "by",
+  "from",
+  "as",
+  "into",
+  "through",
+  "during",
+  "this",
+  "that",
+  "it",
+  "its",
+  "or",
+  "and",
+  "but",
+  "if",
+  "not",
+  "no",
+  "so",
+  "up",
+  "out",
+  "about",
+  "which",
+  "what",
+  "when",
+  "where",
+  "who",
+  "how",
+  "all",
+  "each",
+  "every",
+  "both",
+  "few",
+  "more",
+  "some",
+  "any",
+  "other",
+  "than",
+  "too",
+  "very",
+  "just",
+  "also"
+]);
+function tokenize(text) {
+  const tokens = text.toLowerCase().split(/[^a-z0-9]+/).filter((t) => t.length >= 2 && !STOP_WORDS.has(t));
+  return [...new Set(tokens)];
+}
+
+// src/core/node-selector.ts
+function countHits(tokens, text) {
+  const lower = text.toLowerCase();
+  return tokens.filter((t) => lower.includes(t)).length;
+}
+function collectAspectContent(graphNode, aspects) {
+  const aspectIds = (graphNode.meta.aspects ?? []).map((a) => a.aspect);
+  if (aspectIds.length === 0) return "";
+  const aspectMap = new Map(aspects.map((a) => [a.id, a]));
+  const parts = [];
+  for (const id of aspectIds) {
+    const aspect = aspectMap.get(id);
+    if (aspect) {
+      for (const artifact of aspect.artifacts) {
+        parts.push(artifact.content);
+      }
+    }
+  }
+  return parts.join(" ");
+}
+function scoreNodeS1(graphNode, tokens, aspects) {
+  let score = 0;
+  for (const artifact of graphNode.artifacts) {
+    const hits = countHits(tokens, artifact.content);
+    if (artifact.filename === "responsibility.md") {
+      score += hits * 3;
+    } else if (artifact.filename === "interface.md") {
+      score += hits * 2;
+    } else {
+      score += hits * 1;
+    }
+  }
+  const aspectText = collectAspectContent(graphNode, aspects);
+  if (aspectText) {
+    score += countHits(tokens, aspectText) * 2;
+  }
+  return score;
+}
+function pathDepth(nodePath) {
+  return nodePath.split("/").length;
+}
+function selectNodes(graph, task, limit) {
+  const tokens = tokenize(task);
+  if (tokens.length === 0) return [];
+  const scored = [];
+  for (const [nodePath, node] of graph.nodes) {
+    const score = scoreNodeS1(node, tokens, graph.aspects);
+    if (score > 0) {
+      scored.push({ node: nodePath, score, name: node.meta.name });
+    }
+  }
+  if (scored.length > 0) {
+    scored.sort((a, b) => {
+      if (b.score !== a.score) return b.score - a.score;
+      return pathDepth(b.node) - pathDepth(a.node);
+    });
+    return scored.slice(0, limit);
+  }
+  return selectFromFlows(graph, tokens, limit);
+}
+function selectFromFlows(graph, tokens, limit) {
+  const flowScores = [];
+  for (const flow of graph.flows) {
+    let score = 0;
+    for (const artifact of flow.artifacts) {
+      score += countHits(tokens, artifact.content);
+    }
+    score += countHits(tokens, flow.name);
+    if (score > 0) {
+      flowScores.push({ flow: flow.name, score, participants: flow.nodes });
+    }
+  }
+  if (flowScores.length === 0) return [];
+  flowScores.sort((a, b) => b.score - a.score);
+  const seen = /* @__PURE__ */ new Set();
+  const results = [];
+  for (const fs of flowScores) {
+    for (const participant of fs.participants) {
+      if (seen.has(participant)) continue;
+      seen.add(participant);
+      const node = graph.nodes.get(participant);
+      if (node) {
+        results.push({ node: participant, score: fs.score, name: node.meta.name });
+      }
+    }
+  }
+  return results.slice(0, limit);
+}
+
+// src/cli/select.ts
+function registerSelectCommand(program2) {
+  program2.command("select").description("Find graph nodes relevant to a task description").requiredOption("--task <description>", "Natural-language task description").option("--limit <n>", "Maximum nodes to return", "5").action(async (options) => {
+    try {
+      const yggRoot = await findYggRoot(process.cwd());
+      const graph = await loadGraph(yggRoot);
+      const limit = parseInt(options.limit, 10);
+      if (isNaN(limit) || limit < 1) {
+        process.stderr.write("Error: --limit must be a positive integer\n");
+        process.exit(1);
+      }
+      const results = selectNodes(graph, options.task, limit);
+      process.stdout.write(yamlStringify3(results));
+    } catch (error) {
+      process.stderr.write(`Error: ${error.message}
+`);
+      process.exit(1);
+    }
+  });
+}
+
 // src/bin.ts
 import { readFileSync as readFileSync2 } from "fs";
 import { fileURLToPath as fileURLToPath3 } from "url";
@@ -4532,5 +4735,6 @@ registerImpactCommand(program);
 registerAspectsCommand(program);
 registerFlowsCommand(program);
 registerPreflightCommand(program);
+registerSelectCommand(program);
 program.parse();
 //# sourceMappingURL=bin.js.map