create-agdf 0.14.5 → 0.20.1

package/runtime/core/lib/skill-dispatch/tp-definition.js

@@ -0,0 +1,41 @@
+import { extractField } from "../control-evaluation/verified-change.js";
+import { ARTEFACT_TEMPLATE_IDS, resolveArtefactTemplatePath } from "../resources/artefact-templates.js";
+import { resolveArtifactPresentationLanguages } from "../resources/context.js";
+
+// Pure assignment over evaluated state and checked source facts; no writer or approval.
+export function tpDefinitionPhase(targetDir, control, input, sources) {
+  const state = control?.status_card?.runState;
+  if (control?.next_operation?.type === "reassess_source_analysis") return null;
+  if (input.ur_action !== undefined || input.prd_action !== undefined || input.sd_action !== undefined || !input.run_id
+      || control?.status_card?.run_id !== input.run_id || !state || !sources
+      || control.current_gate !== "TP" || !["open", "blocked"].includes(control.status)
+      || !["none", "Approval: TP"].includes(control.missing_approval)
+      || !["none", "AGDF_TP_TRACEABILITY_INCOMPLETE"].includes(control.blocking_reason)
+      || (control.doctor_report?.findings ?? []).some(f => ["block", "revise"].includes(f.severity))
+      || state.approvals.get("SD")?.status !== "approved"
+      || state.artefacts.get("SD")?.status !== "approved"
+      || state.approvals.get("PRD")?.status !== "approved"
+      || state.artefacts.get("PRD")?.status !== "approved"
+      || state.approvals.get("TP")?.status === "approved"
+      || !["done", "not_applicable"].includes(state.artefacts.get("Brownfield Review")?.status)
+      || !["structured_delivery", "structured_slice"].includes(state.mode_slice_decision?.decision)) return null;
+  if (input.skill_id !== "tp-definition" && !(input.intake || input.continue_delivery)) return null;
+  const revisionId = extractField(state.content ?? "", "revision_id");
+  if (!revisionId) return null;
+  const artifactPath = `.agdf/control/artefacts/${input.run_id}/TP.md`;
+  const artefact = state.artefacts.get("TP");
+  const registered = artefact?.status === "draft";
+  if (artefact?.status === "approved" || (registered
+      && String(artefact.path ?? "").replace(/^`|`$/gu, "") !== artifactPath)) return null;
+  if (registered && input.tp_action !== "revise"
+      && control.traceability_readiness?.ready !== false) return null;
+  return Object.freeze({
+    phase: "tp_definition", skill_id: "tp-definition", governance_target: targetDir,
+    run_id: input.run_id, revision_id: revisionId,
+    ...resolveArtifactPresentationLanguages(targetDir, input.presentation_language),
+    artifact_path: artifactPath, template_path: resolveArtefactTemplatePath(ARTEFACT_TEMPLATE_IDS.TP),
+    source_artifacts: Object.freeze(sources.map(s => s.path)),
+    sources: Object.freeze(sources.map(s => Object.freeze({ ...s }))), draft_registered: registered,
+    instruction: "Execute tp-definition from these exact approved PRD/SD and analytical inputs. Preserve ready drafts without explicit revision intent. Keep criteria-chain-v1, declare tp-decisions-v1, resolve SD later_tp decisions and specify executable evidence obligations. Material questions block approval and require a concrete clarification at the earliest existing source owner; no silent source edits. Use the shared typed recording procedure, then redispatch gate-check for this run with continue_delivery true to obtain its clarification or presentation continuation. Changed drafts require fresh presentation and a new deliberate Approval: TP.",
+  });
+}

package/runtime/core/lib/task-target-resolution.js

@@ -0,0 +1,202 @@
+import { existsSync, realpathSync, statSync } from "node:fs";
+import { dirname, isAbsolute, relative, sep } from "node:path";
+import { resolveRepositoryContextByMarker } from "./repository-context-reader.js";
+
+export const TASK_TARGET_SOURCES = Object.freeze(["explicit_target", "continued_target", "current_repository"]);
+
+export const TASK_TARGET_UNRESOLVED_REASONS = Object.freeze(["multiple_plausible_targets", "target_content_mismatch", "target_unavailable", "no_reliable_target", "target_source_invalid", "working_directory_invalid", "continued_target_changed", "target_path_relative", "target_not_in_repository", "current_repository_root_required", "current_repository_context_mismatch"]);
+
+const TARGET_SOURCES = new Set(TASK_TARGET_SOURCES);
+
+export class TaskTargetInputError extends Error {
+  constructor(field, message, { allowedValues = [] } = {}) {
+    super(message);
+    this.name = "TaskTargetInputError";
+    this.field = field;
+    this.allowedValues = Object.freeze([...allowedValues]);
+  }
+}
+
+export function normalizeTaskTargetSource(value, { allowEmpty = true } = {}) {
+  const targetSource = String(value ?? "").trim();
+  if (!targetSource && allowEmpty) return "";
+  if (!TARGET_SOURCES.has(targetSource)) {
+    throw new TaskTargetInputError(
+      "target_source",
+      `target_source must be one of: ${TASK_TARGET_SOURCES.join(", ")}`,
+      { allowedValues: TASK_TARGET_SOURCES },
+    );
+  }
+  return targetSource;
+}
+
+function canonicalPath(path) {
+  try { return realpathSync(path); } catch { return null; }
+}
+
+function canonicalDirectory(path) {
+  const canonical = canonicalPath(path);
+  try { return canonical && statSync(canonical).isDirectory() ? canonical : ""; } catch { return ""; }
+}
+
+function isInside(root, candidate) {
+  const path = relative(root, candidate);
+  return path === "" || (path !== ".." && !path.startsWith(`..${sep}`) && !isAbsolute(path));
+}
+
+function unresolved(reasonCode, { workingDirectory, evidenceSources = [], targetSource = "", nextAction, inputError = null }) {
+  return Object.freeze({
+    schema_version: "1",
+    resolution_state: "unresolved",
+    reason_code: reasonCode,
+    primary_target: "",
+    evidence_sources: Object.freeze([...evidenceSources]),
+    working_directory: workingDirectory,
+    governance_target: "",
+    target_source: targetSource,
+    target_changed: false,
+    next_action: nextAction,
+    authorizes: false,
+    ...(inputError ? { input_error: Object.freeze(inputError) } : {}),
+  });
+}
+
+function repositoryRoot(target, resolveRepositoryContext) {
+  const start = statSync(target).isDirectory() ? target : dirname(target);
+  const context = resolveRepositoryContext(start);
+  const root = context.context_state === "repository_bound" ? context.repository_root : null;
+  return root && isInside(root, target) ? root : null;
+}
+
+export function resolveTaskTarget(input = {}, dependencies = {}) {
+  const resolveRepositoryContext = dependencies.resolveRepositoryContext ?? resolveRepositoryContextByMarker;
+  const rawWorkingDirectory = String(input.workingDirectory ?? "").trim();
+  const workingDirectory = isAbsolute(rawWorkingDirectory) && existsSync(rawWorkingDirectory)
+    ? canonicalDirectory(rawWorkingDirectory)
+    : "";
+  const evidenceSources = Array.isArray(input.evidenceSources)
+    ? input.evidenceSources.map((item) => String(item ?? "").trim()).filter(Boolean)
+    : [];
+  const candidates = Array.isArray(input.candidates)
+    ? [...new Set(input.candidates.map((item) => String(item ?? "").trim()).filter(Boolean))]
+    : [];
+  const targetSource = String(input.targetSource ?? "").trim();
+  const rawTarget = String(input.primaryTarget ?? "").trim();
+
+  let normalizedTargetSource;
+  try {
+    normalizedTargetSource = normalizeTaskTargetSource(targetSource);
+  } catch (error) {
+    if (!(error instanceof TaskTargetInputError)) throw error;
+    return unresolved("target_source_invalid", {
+      workingDirectory: workingDirectory || rawWorkingDirectory || "unavailable",
+      evidenceSources,
+      nextAction: "Use one allowed target_source value and retry target-check.",
+      inputError: {
+        field: error.field,
+        allowed_values: error.allowedValues,
+      },
+    });
+  }
+
+  if (!workingDirectory) {
+    return unresolved("working_directory_invalid", {
+      workingDirectory: rawWorkingDirectory || "unavailable",
+      evidenceSources,
+      targetSource: normalizedTargetSource,
+      nextAction: "Provide an absolute accessible working directory as execution context.",
+    });
+  }
+  if (candidates.length > 1 || (candidates.length === 1 && rawTarget && candidates[0] !== rawTarget)) {
+    return unresolved("multiple_plausible_targets", {
+      workingDirectory,
+      evidenceSources: [...evidenceSources, ...candidates],
+      targetSource: normalizedTargetSource,
+      nextAction: "Select exactly one primary task target.",
+    });
+  }
+  if (!normalizedTargetSource || !rawTarget) {
+    return unresolved("no_reliable_target", {
+      workingDirectory,
+      evidenceSources,
+      targetSource: normalizedTargetSource,
+      nextAction: "Name one task target and classify it as explicit_target, continued_target or current_repository.",
+    });
+  }
+  if (targetSource === "continued_target" && input.targetChanged === true) {
+    return unresolved("continued_target_changed", {
+      workingDirectory,
+      evidenceSources,
+      targetSource: normalizedTargetSource,
+      nextAction: "Classify a replaced target as explicit_target, not continued_target.",
+    });
+  }
+  if (!isAbsolute(rawTarget)) {
+    return unresolved("target_path_relative", {
+      workingDirectory,
+      evidenceSources,
+      targetSource: normalizedTargetSource,
+      nextAction: "Provide one absolute target path that agrees with the selected target source.",
+    });
+  }
+  if (!existsSync(rawTarget)) {
+    return unresolved("target_unavailable", {
+      workingDirectory,
+      evidenceSources,
+      targetSource: normalizedTargetSource,
+      nextAction: "Make the named target available and retry target-check.",
+    });
+  }
+
+  const primaryTarget = canonicalPath(rawTarget);
+  if (!primaryTarget) {
+    return unresolved("target_unavailable", {
+      workingDirectory,
+      evidenceSources,
+      targetSource: normalizedTargetSource,
+      nextAction: "Make the named target readable and retry target-check.",
+    });
+  }
+  const governanceTarget = repositoryRoot(primaryTarget, resolveRepositoryContext);
+  if (!governanceTarget) {
+    return unresolved("target_not_in_repository", {
+      workingDirectory,
+      evidenceSources,
+      targetSource: normalizedTargetSource,
+      nextAction: "Choose a target inside the Git repository whose governance should be evaluated.",
+    });
+  }
+  if (targetSource === "current_repository" && primaryTarget !== governanceTarget) {
+    return unresolved("current_repository_root_required", {
+      workingDirectory,
+      evidenceSources,
+      targetSource: normalizedTargetSource,
+      nextAction: "For current_repository, provide the verified repository root as the primary target.",
+    });
+  }
+  if (targetSource === "current_repository") {
+    const workingContext = resolveRepositoryContext(workingDirectory);
+    if (workingContext.context_state !== "repository_bound" || workingContext.repository_root !== governanceTarget) {
+      return unresolved("current_repository_context_mismatch", {
+        workingDirectory,
+        evidenceSources,
+        targetSource: normalizedTargetSource,
+        nextAction: "Use current_repository only when the execution context is inside that verified repository.",
+      });
+    }
+  }
+
+  return Object.freeze({
+    schema_version: "1",
+    resolution_state: "resolved",
+    reason_code: targetSource === "continued_target" ? "continued_target" : "explicit_target",
+    primary_target: primaryTarget,
+    evidence_sources: Object.freeze(evidenceSources),
+    working_directory: workingDirectory,
+    governance_target: governanceTarget,
+    target_source: targetSource,
+    target_changed: input.targetChanged === true,
+    next_action: "",
+    authorizes: false,
+  });
+}

package/runtime/core/node_modules/entities/LICENSE

@@ -0,0 +1,11 @@
+Copyright (c) Felix Böhm
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
+
+Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
+
+Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
+
+THIS IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS,
+EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

package/runtime/core/node_modules/entities/decode.js

@@ -0,0 +1,3 @@
+// Make exports work in Node < 12
+// eslint-disable-next-line no-undef, unicorn/prefer-module
+module.exports = require("./dist/commonjs/decode.js");

package/runtime/core/node_modules/entities/dist/commonjs/decode-codepoint.js

@@ -0,0 +1,77 @@
+"use strict";
+// Adapted from https://github.com/mathiasbynens/he/blob/36afe179392226cf1b6ccdb16ebbb7a5a844d93a/src/he.js#L106-L134
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fromCodePoint = void 0;
+exports.replaceCodePoint = replaceCodePoint;
+exports.decodeCodePoint = decodeCodePoint;
+const decodeMap = new Map([
+    [0, 65533],
+    // C1 Unicode control character reference replacements
+    [128, 8364],
+    [130, 8218],
+    [131, 402],
+    [132, 8222],
+    [133, 8230],
+    [134, 8224],
+    [135, 8225],
+    [136, 710],
+    [137, 8240],
+    [138, 352],
+    [139, 8249],
+    [140, 338],
+    [142, 381],
+    [145, 8216],
+    [146, 8217],
+    [147, 8220],
+    [148, 8221],
+    [149, 8226],
+    [150, 8211],
+    [151, 8212],
+    [152, 732],
+    [153, 8482],
+    [154, 353],
+    [155, 8250],
+    [156, 339],
+    [158, 382],
+    [159, 376],
+]);
+/**
+ * Polyfill for `String.fromCodePoint`. It is used to create a string from a Unicode code point.
+ */
+exports.fromCodePoint = 
+// eslint-disable-next-line @typescript-eslint/no-unnecessary-condition, n/no-unsupported-features/es-builtins
+(_a = String.fromCodePoint) !== null && _a !== void 0 ? _a : function (codePoint) {
+    let output = "";
+    if (codePoint > 65535) {
+        codePoint -= 65536;
+        output += String.fromCharCode(((codePoint >>> 10) & 1023) | 55296);
+        codePoint = 56320 | (codePoint & 1023);
+    }
+    output += String.fromCharCode(codePoint);
+    return output;
+};
+/**
+ * Replace the given code point with a replacement character if it is a
+ * surrogate or is outside the valid range. Otherwise return the code
+ * point unchanged.
+ */
+function replaceCodePoint(codePoint) {
+    var _a;
+    if ((codePoint >= 55296 && codePoint <= 57343) ||
+        codePoint > 1114111) {
+        return 65533;
+    }
+    return (_a = decodeMap.get(codePoint)) !== null && _a !== void 0 ? _a : codePoint;
+}
+/**
+ * Replace the code point if relevant, then convert it to a string.
+ *
+ * @deprecated Use `fromCodePoint(replaceCodePoint(codePoint))` instead.
+ * @param codePoint The code point to decode.
+ * @returns The decoded code point.
+ */
+function decodeCodePoint(codePoint) {
+    return (0, exports.fromCodePoint)(replaceCodePoint(codePoint));
+}
+//# sourceMappingURL=decode-codepoint.js.map