@juzser/blacksmith 0.3.0 → 0.4.0

package/factory/orchestrator/dist/paths.js

@@ -11,6 +11,16 @@ const here = path.dirname(fileURLToPath(import.meta.url));
  * assets ships in the tarball. `packaging.test.ts` holds that claim.
  */
 export const REPO_ROOT = path.resolve(here, '..', '..', '..');
+/**
+ * Is `dir` this factory's own checkout, resolved rather than compared raw so
+ * a trailing slash or a relative path names the same answer. `audit.ts`
+ * (`auditedProjectName`) and `projects.ts` (`unwatchedProjects`) both need to
+ * tell "this clone, filed under its own directory name" from "a project that
+ * is genuinely named that" and used to each spell the comparison themselves.
+ */
+export function isFactoryCheckout(dir) {
+    return path.resolve(dir) === path.resolve(REPO_ROOT);
+}
 /**
  * Is this module running out of the blacksmith clone, or out of an installed
  * copy of the package?

package/factory/orchestrator/dist/plan.js

@@ -6,6 +6,7 @@ import { SmithError } from './errors.js';
 import { topoSort } from './graph.js';
 import { SPECS_ACTIVE_DIR } from './paths.js';
 import { compileSchemas, validateRecord, } from './schemas.js';
+import { epicOfTaskId } from './taskId.js';
 import { loadTaxonomy, TaxonomyError, validateRequiredDimensions, } from './taxonomy.js';
 export class PlanError extends SmithError {
 }
@@ -133,6 +134,122 @@ export function loadPlan(epicId, version, opts = {}) {
     }
     return JSON.parse(readFileSync(filePath, 'utf8'));
 }
+/**
+ * A task ref's project, read off its own epic's latest plan version -- the
+ * D-246 precedent (`db/projector.ts`'s `planProjectResolver`, for the board)
+ * restated here so `errorIssues.ts` can answer the same question without
+ * importing anything database-shaped (`test/cliBoot.test.ts` pins `cli.ts`'s
+ * built module graph off drizzle/sqlite entirely, and `cli.ts` statically
+ * imports the error-issue reporter).
+ *
+ * Never throws and never guesses: an id with no epic segment, an epic with
+ * no plan on disk, and an unreadable or unparseable plan file all answer
+ * `null` alike, on purpose -- "cannot tell" and "the plan has no project" are
+ * the same non-answer to a caller that must never turn either one into this
+ * factory's own name. Answers cache by epic id for the resolver's lifetime,
+ * since one `issues report` run reads the same epic's plan for every row
+ * that epic contributed.
+ */
+export function planProjectResolverForTaskRef(opts = {}) {
+    const cache = new Map();
+    return (taskRef) => {
+        const epicId = epicOfTaskId(taskRef);
+        if (epicId === null)
+            return null;
+        const cached = cache.get(epicId);
+        if (cached !== undefined)
+            return cached;
+        let project = null;
+        try {
+            const version = latestPlanVersion(epicId, opts);
+            if (version !== null)
+                project = loadPlan(epicId, version, opts).project ?? null;
+        }
+        catch {
+            // Unreadable or unparseable plan file: no answer, not a crash.
+        }
+        cache.set(epicId, project);
+        return project;
+    };
+}
+/**
+ * Whether `opts.specsDir` names THIS checkout's own specs/active tree --
+ * absent (so `planFilePath`/`latestPlanVersion` fall back to
+ * `SPECS_ACTIVE_DIR` themselves) or an explicit path that resolves to the
+ * same directory. Only then is a plan found there, naming no project,
+ * evidence of "self": `--specs-dir` is also how a caller points this
+ * resolver at a DIFFERENT checkout's specs tree entirely -- `issueInputs`'s
+ * own doc comment names "the daemon's own event log and a target checkout's
+ * specs tree" as an intended use -- and a plan found THERE naming no project
+ * is that other project's own silence, not this factory's (S2-b).
+ */
+function isSelfSpecsDir(opts) {
+    return opts.specsDir === undefined || path.resolve(opts.specsDir) === SPECS_ACTIVE_DIR;
+}
+/**
+ * The self-fallback half of `planProjectResolverForTaskRefOrSelf`, on its
+ * own: a plan found on disk for the epic that simply declares no `project`
+ * field IS this factory's own project, by construction -- only this
+ * checkout's own epics have a plan under `specs/active` at all, so finding
+ * one there is itself the "self" signal a foreign epic's plan (which lives
+ * in the foreign project's own specs tree, never this one) can never
+ * produce. An epic with no plan on disk anywhere, or a bare ref with no
+ * epic segment, answers `null` -- "cannot tell whose project this is" --
+ * because plan.ts must not be the module that hardcodes this factory's
+ * name; the caller supplies it.
+ *
+ * That "only this checkout's own epics" premise holds only while `opts`
+ * actually points at this checkout's own specs/active tree
+ * (`isSelfSpecsDir`, S2-b): a caller that redirected `--specs-dir` at some
+ * OTHER checkout's specs tree gets no self-fallback at all, `null` only,
+ * because a plan found there naming no project is that other checkout's own
+ * silence, not this factory's.
+ *
+ * Exported as its own resolver, separate from `planProjectResolverForTaskRef`
+ * (S2-c): production callers (`cli.ts`'s `issueInputs`) hand the two to
+ * `withSessionFallback`/`foldErrorEvents` as DISTINCT tiers -- the strict
+ * resolver first, then a session's own unanimous stamp, and only then this
+ * guess -- so a session-mate's real stamp naming a different project
+ * outranks this weakest signal rather than losing to it, which is what
+ * happened when the two were folded into one resolver and tried together as
+ * a single first tier.
+ */
+export function planSelfFallbackForTaskRef(selfProject, opts = {}) {
+    const selfEligible = isSelfSpecsDir(opts);
+    const hasPlanCache = new Map();
+    return (taskRef) => {
+        if (!selfEligible)
+            return null;
+        const epicId = epicOfTaskId(taskRef);
+        if (epicId === null)
+            return null;
+        let hasPlan = hasPlanCache.get(epicId);
+        if (hasPlan === undefined) {
+            hasPlan = latestPlanVersion(epicId, opts) !== null;
+            hasPlanCache.set(epicId, hasPlan);
+        }
+        return hasPlan ? selfProject : null;
+    };
+}
+/**
+ * `planProjectResolverForTaskRef` composed with `planSelfFallbackForTaskRef`
+ * as a single resolver, direct answer first and self-fallback second, for
+ * callers that want the OLD combined behavior (both tiers tried back to
+ * back, with nothing -- such as a session stamp -- able to sit between
+ * them). Kept for callers that do not need the S2-c tier split; `cli.ts`'s
+ * `issueInputs` no longer uses this, it hands the two halves to
+ * `withSessionFallback` separately instead.
+ */
+export function planProjectResolverForTaskRefOrSelf(selfProject, opts = {}) {
+    const resolve = planProjectResolverForTaskRef(opts);
+    const selfFallback = planSelfFallbackForTaskRef(selfProject, opts);
+    return (taskRef) => {
+        const direct = resolve(taskRef);
+        if (direct !== null)
+            return direct;
+        return selfFallback(taskRef);
+    };
+}
 /**
  * Reduce an `output_schema_ref` to the name the compiled schema set knows it
  * by. `compileSchemas` keys on filename-minus-`.schema.json`, so a path, a
@@ -509,6 +626,19 @@ export function livePlanTasks(plan) {
     }
     return live;
 }
+/**
+ * The plan's tasks in the shape `resolveFindingOwner` reads: only the live
+ * (D-126) ones, and only the `claims` field ownership resolution needs. This
+ * is `livePlanTasks` restated as claims rather than full specs, so a caller
+ * asking "does some task in this plan still claim that file?" (`audit
+ * resolve`) gets the same live/superseded rule `epic verdict` does, not the
+ * raw `plan.tasks` array that also holds every amendment left behind.
+ */
+export function planClaimedTasks(plan) {
+    return livePlanTasks(plan)
+        .filter((task) => Array.isArray(task.claims))
+        .map((task) => ({ task_id: task.task_id, claims: task.claims }));
+}
 /**
  * What makes two records the same *spec*: everything except the version stamp
  * and the workflow status. `nextVersion` rewrites `plan_version` on every

package/factory/orchestrator/dist/projects.js

@@ -32,7 +32,7 @@
 // silent exactly when somebody is editing (D-21).
 import { existsSync } from 'node:fs';
 import path from 'node:path';
-import { PROJECTS_DIR, REPO_ROOT, WORKSPACES_DIR } from './paths.js';
+import { isFactoryCheckout, PROJECTS_DIR, REPO_ROOT, WORKSPACES_DIR } from './paths.js';
 import { FACTORY_PROJECT, loadRoadmap } from './roadmap.js';
 function collectProjects(opts) {
     const roots = opts.roots ?? [PROJECTS_DIR, WORKSPACES_DIR];
@@ -58,6 +58,17 @@ function collectProjects(opts) {
             missing.push({ name, roots });
             continue;
         }
+        // Dedupe by name alone is not enough: a self-audit's cut can stamp this
+        // clone's OWN directory name onto a milestone rather than FACTORY_PROJECT
+        // (audit.ts's `auditedProjectName`), and that name is never in `seen`.
+        // Left unchecked, `firstCheckout` resolves it to REPO_ROOT -- PROJECTS_DIR
+        // is this clone's own parent -- and this clone gets registered a second
+        // time as a foreign, non-self ref that `--no-self` cannot filter
+        // (`resolveProjectDirs` only ever drops the entry at index 0). Self
+        // already leads `refs`; a checkout that resolves to REPO_ROOT is that
+        // entry under another name, so it is skipped rather than pushed again.
+        if (isFactoryCheckout(dir))
+            continue;
         refs.push({ name, dir, self: false });
     }
     return { refs, missing };