@nyxa/nyx-agent 0.4.1 → 0.5.0

package/dist/runtime/validateWorkItem.js

@@ -1,212 +0,0 @@
-import path from "node:path";
-export function validateWorkItemIdentity(input) {
-    const workItems = input.config.work_items;
-    if (!workItems) {
-        return {
-            ok: false,
-            error: "Selected work item requires configured [work_items]"
-        };
-    }
-    if (!isRecord(input.workItem)) {
-        return { ok: false, error: "Selected work item must be an object" };
-    }
-    const source = input.workItem.source;
-    if (!isRecord(source)) {
-        return { ok: false, error: "Selected work item source must be an object" };
-    }
-    const key = input.workItem.key;
-    const sourceType = source.type;
-    const locator = source.locator;
-    if (typeof key !== "string" || key.length === 0) {
-        return { ok: false, error: "Selected work item key must be a non-empty string" };
-    }
-    if (input.seenWorkItemKeys?.includes(key) && key !== input.allowKnownKey) {
-        return {
-            ok: false,
-            error: `Selected work item key "${key}" was already seen in this run`
-        };
-    }
-    if (input.completedWorkItemKeys?.includes(key) &&
-        key !== input.allowKnownKey) {
-        return {
-            ok: false,
-            error: `Selected work item key "${key}" is already completed`
-        };
-    }
-    if (sourceType !== workItems.source) {
-        return {
-            ok: false,
-            error: `Selected work item source.type must be "${workItems.source}"`
-        };
-    }
-    if (typeof locator !== "string" || locator.length === 0) {
-        return {
-            ok: false,
-            error: "Selected work item source.locator must be a non-empty string"
-        };
-    }
-    if (key !== `${workItems.source}:${locator}`) {
-        return {
-            ok: false,
-            error: `Selected work item key must be "${workItems.source}:${locator}"`
-        };
-    }
-    if (workItems.source === "local") {
-        const localValidation = validateLocalLocator(locator, workItems.path);
-        if (!localValidation.ok) {
-            return localValidation;
-        }
-    }
-    else {
-        const githubValidation = validateGitHubLocator(locator, workItems.repository);
-        if (!githubValidation.ok) {
-            return githubValidation;
-        }
-    }
-    if (input.availableWorkItems) {
-        return validateCandidateMembership({
-            key,
-            sourceType,
-            locator,
-            availableWorkItems: input.availableWorkItems
-        });
-    }
-    return { ok: true };
-}
-export function validateWorkItemQueue(input) {
-    if (!Array.isArray(input.workItems)) {
-        return {
-            ok: false,
-            error: "Selected work_items must be an array"
-        };
-    }
-    if (input.workItems.length === 0) {
-        return {
-            ok: false,
-            error: "Selected work_items must contain at least one item"
-        };
-    }
-    const seen = new Set();
-    const normalized = [];
-    for (const [index, workItem] of input.workItems.entries()) {
-        const validation = validateWorkItemIdentity({
-            config: input.config,
-            workItem,
-            availableWorkItems: input.availableWorkItems,
-            seenWorkItemKeys: input.seenWorkItemKeys,
-            completedWorkItemKeys: input.completedWorkItemKeys
-        });
-        if (!validation.ok) {
-            return {
-                ok: false,
-                error: `Selected work_items[${index}] ${validation.error}`
-            };
-        }
-        const key = readObjectProperty(workItem, "key");
-        if (typeof key !== "string") {
-            return {
-                ok: false,
-                error: `Selected work_items[${index}] key must be a string`
-            };
-        }
-        if (seen.has(key)) {
-            return {
-                ok: false,
-                error: `Selected work_items contains duplicate key "${key}"`
-            };
-        }
-        seen.add(key);
-        const candidate = input.availableWorkItems?.find((item) => item.key === key);
-        normalized.push(candidate ?? workItem);
-    }
-    return { ok: true, workItems: normalized };
-}
-function validateCandidateMembership(input) {
-    const candidate = input.availableWorkItems.find((item) => item.key === input.key);
-    if (!candidate) {
-        return {
-            ok: false,
-            error: `Selected work item key "${input.key}" is not in available_work_items`
-        };
-    }
-    if (candidate.source.type !== input.sourceType ||
-        candidate.source.locator !== input.locator) {
-        return {
-            ok: false,
-            error: `Selected work item source does not match available_work_items entry "${input.key}"`
-        };
-    }
-    return { ok: true };
-}
-function validateLocalLocator(locator, configuredPath) {
-    const normalizedLocator = normalizeRelativePath(locator);
-    const normalizedPath = configuredPath
-        ? normalizeRelativePath(configuredPath)
-        : undefined;
-    if (!normalizedLocator || normalizedLocator !== locator) {
-        return {
-            ok: false,
-            error: "Local work item locator must be a canonical relative path"
-        };
-    }
-    if (!normalizedPath) {
-        return {
-            ok: false,
-            error: "Local work item validation requires [work_items].path"
-        };
-    }
-    if (normalizedLocator !== normalizedPath &&
-        !normalizedLocator.startsWith(`${normalizedPath}/`)) {
-        return {
-            ok: false,
-            error: `Local work item locator must stay under "${normalizedPath}"`
-        };
-    }
-    return { ok: true };
-}
-function validateGitHubLocator(locator, repository) {
-    if (!repository) {
-        return {
-            ok: false,
-            error: "GitHub work item validation requires [work_items].repository"
-        };
-    }
-    const match = /^([A-Za-z0-9_.-]+\/[A-Za-z0-9_.-]+)#([1-9][0-9]*)$/.exec(locator);
-    if (!match) {
-        return {
-            ok: false,
-            error: 'GitHub work item locator must use "owner/repo#number"'
-        };
-    }
-    if (match[1] !== repository) {
-        return {
-            ok: false,
-            error: `GitHub work item locator must use repository "${repository}"`
-        };
-    }
-    return { ok: true };
-}
-function normalizeRelativePath(value) {
-    if (value.length === 0 ||
-        value.includes("\\") ||
-        path.posix.isAbsolute(value) ||
-        /^[A-Za-z]:[\\/]/.test(value)) {
-        return undefined;
-    }
-    const normalized = path.posix.normalize(value);
-    if (normalized === "." || normalized === ".." || normalized.startsWith("../")) {
-        return undefined;
-    }
-    return normalized;
-}
-function isRecord(value) {
-    return Boolean(value && typeof value === "object" && !Array.isArray(value));
-}
-function readObjectProperty(value, key) {
-    if (value &&
-        typeof value === "object" &&
-        Object.prototype.hasOwnProperty.call(value, key)) {
-        return value[key];
-    }
-    return undefined;
-}

package/dist/runtime/workItemAnnotations.js

@@ -1,39 +0,0 @@
-export const workItemKinds = ["task", "plan", "prd", "work"];
-export function normalizeWorkItemAnnotations(input) {
-    if (!Array.isArray(input.annotations)) {
-        return [];
-    }
-    const availableKeys = new Set(input.availableWorkItems.map((item) => item.key));
-    const seen = new Set();
-    const normalized = [];
-    for (const annotation of input.annotations) {
-        if (!isRecord(annotation) || typeof annotation.key !== "string") {
-            continue;
-        }
-        if (!availableKeys.has(annotation.key) || seen.has(annotation.key)) {
-            continue;
-        }
-        seen.add(annotation.key);
-        normalized.push({
-            key: annotation.key,
-            kind: normalizeWorkItemKind(annotation.kind)
-        });
-    }
-    return normalized;
-}
-export function buildWorkItemKindMap(annotations) {
-    return new Map(annotations.map((annotation) => [annotation.key, annotation.kind]));
-}
-export function formatWorkItemChoiceName(input) {
-    const kind = input.annotationsByKey.get(input.item.key) ?? "work";
-    return `[${kind}] ${input.item.title} (${input.item.key})`;
-}
-function normalizeWorkItemKind(value) {
-    return typeof value === "string" && isWorkItemKind(value) ? value : "work";
-}
-function isWorkItemKind(value) {
-    return workItemKinds.includes(value);
-}
-function isRecord(value) {
-    return Boolean(value && typeof value === "object" && !Array.isArray(value));
-}