@lumenflow/cli 5.5.0 → 5.7.12

package/packs/software-delivery/pack-registration.ts

@@ -1,113 +0,0 @@
-// Copyright (c) 2026 Hellmai Ltd
-// SPDX-License-Identifier: LicenseRef-LumenFlow-Proprietary
-
-import { createHash } from 'node:crypto';
-import { readdir, readFile } from 'node:fs/promises';
-import path from 'node:path';
-import { fileURLToPath } from 'node:url';
-import {
-  SHA256_ALGORITHM,
-  SOFTWARE_DELIVERY_MANIFEST_FILE_NAME,
-  UTF8_ENCODING,
-} from './constants.js';
-import { SOFTWARE_DELIVERY_MANIFEST, type SoftwareDeliveryPackManifest } from './manifest.js';
-
-const NULL_BYTE_BUFFER = Buffer.from([0]);
-const DEFAULT_EXCLUSIONS = ['node_modules/', '.git/', 'dist/', '.DS_Store'];
-
-function getDefaultPackRoot(): string {
-  return path.dirname(fileURLToPath(import.meta.url));
-}
-
-function normalizeRelativePath(root: string, absolutePath: string): string {
-  return path.relative(root, absolutePath).split(path.sep).join('/');
-}
-
-function shouldExclude(relativePath: string, exclusions: readonly string[]): boolean {
-  return exclusions.some((excluded) => {
-    if (excluded.endsWith('/')) {
-      return relativePath.startsWith(excluded);
-    }
-    return relativePath === excluded || relativePath.endsWith(`/${excluded}`);
-  });
-}
-
-async function collectFilesRecursive(root: string, directory: string): Promise<string[]> {
-  const entries = await readdir(directory, { withFileTypes: true });
-  const sortedEntries = [...entries].sort((left, right) => left.name.localeCompare(right.name));
-  const files: string[] = [];
-
-  for (const entry of sortedEntries) {
-    const absolutePath = path.join(directory, entry.name);
-    const relativePath = normalizeRelativePath(root, absolutePath);
-    if (entry.isDirectory()) {
-      files.push(...(await collectFilesRecursive(root, absolutePath)));
-      continue;
-    }
-    files.push(relativePath);
-  }
-
-  return files;
-}
-
-async function listPackFiles(packRoot: string, exclusions: readonly string[]): Promise<string[]> {
-  const absoluteRoot = path.resolve(packRoot);
-  const allFiles = await collectFilesRecursive(absoluteRoot, absoluteRoot);
-  return allFiles.filter((relativePath) => !shouldExclude(relativePath, exclusions)).sort();
-}
-
-export async function computeSoftwareDeliveryPackIntegrity(
-  packRoot = getDefaultPackRoot(),
-  exclusions: readonly string[] = DEFAULT_EXCLUSIONS,
-): Promise<`sha256:${string}`> {
-  const absoluteRoot = path.resolve(packRoot);
-  const files = await listPackFiles(absoluteRoot, exclusions);
-  const digestChunks: Buffer[] = [];
-
-  for (const relativePath of files) {
-    const fileContents = await readFile(path.join(absoluteRoot, relativePath));
-    const fileHash = createHash(SHA256_ALGORITHM).update(fileContents).digest('hex');
-    digestChunks.push(Buffer.from(relativePath, UTF8_ENCODING));
-    digestChunks.push(NULL_BYTE_BUFFER);
-    digestChunks.push(Buffer.from(fileHash, UTF8_ENCODING));
-    digestChunks.push(NULL_BYTE_BUFFER);
-  }
-
-  const combinedDigest = createHash(SHA256_ALGORITHM)
-    .update(digestChunks.length === 0 ? Buffer.alloc(0) : Buffer.concat(digestChunks))
-    .digest('hex');
-
-  return `sha256:${combinedDigest}`;
-}
-
-export async function loadSoftwareDeliveryManifest(
-  packRoot = getDefaultPackRoot(),
-): Promise<SoftwareDeliveryPackManifest> {
-  const manifestPath = path.join(path.resolve(packRoot), SOFTWARE_DELIVERY_MANIFEST_FILE_NAME);
-  await readFile(manifestPath, UTF8_ENCODING);
-  return structuredClone(SOFTWARE_DELIVERY_MANIFEST);
-}
-
-export interface RegisteredSoftwareDeliveryPack {
-  manifest: SoftwareDeliveryPackManifest;
-  packRoot: string;
-  manifestPath: string;
-  integrity: `sha256:${string}`;
-}
-
-export async function registerSoftwareDeliveryPack(options?: {
-  packRoot?: string;
-  exclusions?: readonly string[];
-}): Promise<RegisteredSoftwareDeliveryPack> {
-  const packRoot = path.resolve(options?.packRoot ?? getDefaultPackRoot());
-  const exclusions = options?.exclusions ?? DEFAULT_EXCLUSIONS;
-  const manifest = await loadSoftwareDeliveryManifest(packRoot);
-  const integrity = await computeSoftwareDeliveryPackIntegrity(packRoot, exclusions);
-
-  return {
-    manifest,
-    packRoot,
-    manifestPath: path.join(packRoot, SOFTWARE_DELIVERY_MANIFEST_FILE_NAME),
-    integrity,
-  };
-}

package/packs/software-delivery/src/commands/index.ts

@@ -1,5 +0,0 @@
-// Copyright (c) 2026 Hellmai Ltd
-// SPDX-License-Identifier: LicenseRef-LumenFlow-Proprietary
-
-// Barrel for pack-cli-handlers. Populated by Layer 5 of INIT-058.
-export {};

package/packs/software-delivery/src/config/delivery-review-contract.ts

@@ -1,256 +0,0 @@
-// Copyright (c) 2026 Hellmai Ltd
-// SPDX-License-Identifier: LicenseRef-LumenFlow-Proprietary
-
-import { z } from 'zod';
-import { asRecord } from '@lumenflow/kernel/primitives/object-guards';
-import { LUMENFLOW_CLIENT_IDS } from '../constants/client-ids.js';
-import { WU_TYPES } from '../constants/wu-statuses.js';
-
-/**
- * Pack-local delivery review contract surface.
- *
- * Keeping this module in the pack avoids a package cycle with @lumenflow/core
- * while preserving the same public API for pack consumers.
- */
-
-export const DELIVERY_REVIEW_COMMAND_CONTEXTS = {
-  GATES: 'gates',
-  WU_PREP: 'wu:prep',
-} as const;
-
-export type DeliveryReviewCommandContext =
-  (typeof DELIVERY_REVIEW_COMMAND_CONTEXTS)[keyof typeof DELIVERY_REVIEW_COMMAND_CONTEXTS];
-
-export const DEFAULT_DELIVERY_REVIEW_SKIP_TYPES = [
-  WU_TYPES.DOCUMENTATION,
-  WU_TYPES.PROCESS,
-] as const;
-
-export const DELIVERY_REVIEW_ARTIFACT_DIR = '.lumenflow/artifacts/delivery-review' as const;
-
-export const DeliveryReviewGateConfigSchema = z
-  .object({
-    enabled: z.boolean().default(false),
-    skip_types: z.array(z.string().min(1)).default([...DEFAULT_DELIVERY_REVIEW_SKIP_TYPES]),
-  })
-  .strict();
-
-export type DeliveryReviewGateConfig = z.infer<typeof DeliveryReviewGateConfigSchema>;
-
-export const DeliveryReviewClientFeatureSchema = z
-  .object({
-    enabled: z.boolean().default(false),
-    auto_run: z.boolean().default(false),
-  })
-  .strict();
-
-export type DeliveryReviewClientFeature = z.infer<typeof DeliveryReviewClientFeatureSchema>;
-
-export const DeliveryReviewVerdictSchema = z.enum(['PASS', 'FAIL', 'PARTIAL']);
-export type DeliveryReviewVerdict = z.infer<typeof DeliveryReviewVerdictSchema>;
-
-export const DeliveryReviewFindingSeveritySchema = z.enum(['critical', 'high', 'medium', 'low']);
-export type DeliveryReviewFindingSeverity = z.infer<typeof DeliveryReviewFindingSeveritySchema>;
-
-export const DeliveryReviewFindingSchema = z
-  .object({
-    severity: DeliveryReviewFindingSeveritySchema,
-    title: z.string().min(1),
-    detail: z.string().min(1),
-    acceptanceCriteriaRefs: z.array(z.string().min(1)).optional(),
-    fileRefs: z.array(z.string().min(1)).optional(),
-  })
-  .strict();
-
-export type DeliveryReviewFinding = z.infer<typeof DeliveryReviewFindingSchema>;
-
-export const DeliveryReviewAcceptanceCriterionSchema = z
-  .object({
-    criterion: z.string().min(1),
-    status: z.enum(['satisfied', 'unclear', 'not_satisfied']),
-    evidence: z.array(z.string().min(1)).optional(),
-  })
-  .strict();
-
-export type DeliveryReviewAcceptanceCriterion = z.infer<
-  typeof DeliveryReviewAcceptanceCriterionSchema
->;
-
-export const DeliveryReviewResultSchema = z
-  .object({
-    wuId: z.string().min(1),
-    verdict: DeliveryReviewVerdictSchema,
-    summary: z.string().min(1),
-    findings: z.array(DeliveryReviewFindingSchema),
-    acceptanceCriteria: z.array(DeliveryReviewAcceptanceCriterionSchema),
-    metadata: z
-      .object({
-        runtimeClient: z.string().min(1).optional(),
-        startedAt: z.string().datetime(),
-        completedAt: z.string().datetime(),
-      })
-      .strict(),
-  })
-  .strict();
-
-export type DeliveryReviewResult = z.infer<typeof DeliveryReviewResultSchema>;
-
-export interface DeliveryReviewRuntimeConfigInput {
-  gates?: {
-    delivery_review?: unknown;
-  };
-  agents?: {
-    defaultClient?: unknown;
-    clients?: Record<string, unknown>;
-  };
-}
-
-export interface ResolvedDeliveryReviewRuntimeConfig {
-  clientName: string;
-  gate: DeliveryReviewGateConfig;
-  feature: DeliveryReviewClientFeature;
-  enabled: boolean;
-  autoRun: boolean;
-}
-
-function resolveClientNameFromOptions(options: {
-  config: DeliveryReviewRuntimeConfigInput;
-  clientName?: string;
-  env?: Readonly<Record<string, string | undefined>>;
-}): string {
-  const explicitClient = options.clientName?.trim();
-  if (explicitClient) {
-    return explicitClient;
-  }
-
-  const envClient = options.env?.LUMENFLOW_CLIENT?.trim();
-  if (envClient) {
-    return envClient;
-  }
-
-  const defaultClient =
-    typeof options.config.agents?.defaultClient === 'string'
-      ? options.config.agents.defaultClient.trim()
-      : '';
-  if (defaultClient) {
-    return defaultClient;
-  }
-
-  return LUMENFLOW_CLIENT_IDS.CLAUDE_CODE;
-}
-
-function resolveClientRecord(
-  clients: Record<string, unknown> | undefined,
-  clientName: string,
-): Record<string, unknown> | null {
-  if (!clients) {
-    return null;
-  }
-
-  const exactMatch = asRecord(clients[clientName]);
-  if (exactMatch) {
-    return exactMatch;
-  }
-
-  const matchKey = Object.keys(clients).find(
-    (key) => key.toLowerCase() === clientName.toLowerCase(),
-  );
-  return matchKey ? asRecord(clients[matchKey]) : null;
-}
-
-export function resolveDeliveryReviewRuntimeState(options: {
-  config: DeliveryReviewRuntimeConfigInput;
-  clientName?: string;
-  env?: Readonly<Record<string, string | undefined>>;
-}): ResolvedDeliveryReviewRuntimeConfig {
-  const clientName = resolveClientNameFromOptions(options);
-  const gate = DeliveryReviewGateConfigSchema.parse(options.config.gates?.delivery_review ?? {});
-  const clientConfig = resolveClientRecord(options.config.agents?.clients, clientName);
-  const features = asRecord(clientConfig?.features);
-  const feature = DeliveryReviewClientFeatureSchema.parse(features?.delivery_review ?? {});
-
-  return {
-    clientName,
-    gate,
-    feature,
-    enabled: gate.enabled && feature.enabled,
-    autoRun: gate.enabled && feature.enabled && feature.auto_run,
-  };
-}
-
-export function shouldRunDeliveryReviewForCommand(options: {
-  runtime: ResolvedDeliveryReviewRuntimeConfig;
-  commandContext: DeliveryReviewCommandContext;
-}): boolean {
-  if (!options.runtime.enabled) {
-    return false;
-  }
-
-  if (options.commandContext === DELIVERY_REVIEW_COMMAND_CONTEXTS.WU_PREP) {
-    return options.runtime.autoRun;
-  }
-
-  return true;
-}
-
-export function isDeliveryReviewSkippedForType(options: {
-  gate: DeliveryReviewGateConfig;
-  wuType?: unknown;
-}): boolean {
-  if (typeof options.wuType !== 'string' || options.wuType.trim().length === 0) {
-    return false;
-  }
-
-  return options.gate.skip_types.includes(options.wuType);
-}
-
-export function flattenDeliveryReviewAcceptanceCriteria(acceptance: unknown): string[] {
-  if (Array.isArray(acceptance)) {
-    return acceptance
-      .filter((entry): entry is string => typeof entry === 'string')
-      .map((entry) => entry.trim())
-      .filter(Boolean);
-  }
-
-  const acceptanceRecord = asRecord(acceptance);
-  if (!acceptanceRecord) {
-    return [];
-  }
-
-  return Object.values(acceptanceRecord)
-    .flatMap((entry) =>
-      Array.isArray(entry)
-        ? entry.filter((value): value is string => typeof value === 'string')
-        : [],
-    )
-    .map((entry) => entry.trim())
-    .filter(Boolean);
-}
-
-export function calculateDeliveryReviewVerdict(input: {
-  findings: DeliveryReviewFinding[];
-  acceptanceCriteria: DeliveryReviewAcceptanceCriterion[];
-}): DeliveryReviewVerdict {
-  const hasBlockingFinding = input.findings.some(
-    (finding) => finding.severity === 'critical' || finding.severity === 'high',
-  );
-  if (hasBlockingFinding) {
-    return 'FAIL';
-  }
-
-  const hasUnsatisfiedCriterion = input.acceptanceCriteria.some(
-    (criterion) => criterion.status === 'not_satisfied',
-  );
-  if (hasUnsatisfiedCriterion) {
-    return 'FAIL';
-  }
-
-  const hasUnclearCriterion = input.acceptanceCriteria.some(
-    (criterion) => criterion.status === 'unclear',
-  );
-  if (hasUnclearCriterion || input.findings.length > 0) {
-    return 'PARTIAL';
-  }
-
-  return 'PASS';
-}

package/packs/software-delivery/src/config/env-accessors.ts

@@ -1,66 +0,0 @@
-// Copyright (c) 2026 Hellmai Ltd
-// SPDX-License-Identifier: LicenseRef-LumenFlow-Proprietary
-
-import { createError, ErrorCodes } from '@lumenflow/kernel/primitives/error-handler';
-
-/**
- * Pack-local environment access helpers.
- *
- * These stay local to the pack so clean workspace builds do not need to route
- * back through @lumenflow/core, which already depends on this pack.
- */
-
-export interface GetEnvOptions {
-  env?: NodeJS.ProcessEnv;
-  trim?: boolean;
-}
-
-export interface RequireEnvOptions extends GetEnvOptions {
-  context?: string;
-  remediation?: string;
-}
-
-const DEFAULT_REMEDIATION_SUFFIX = 'Set the environment variable and retry.';
-const CONTEXT_SEPARATOR = ': ';
-
-function getEnvSource(options: GetEnvOptions): NodeJS.ProcessEnv {
-  return options.env ?? process.env;
-}
-
-export function getEnv(envVar: string, options: GetEnvOptions = {}): string | undefined {
-  const source = getEnvSource(options);
-  const rawValue = source[envVar];
-  if (rawValue === undefined) {
-    return undefined;
-  }
-
-  const trimValue = options.trim ?? true;
-  const normalizedValue = trimValue ? rawValue.trim() : rawValue;
-  if (normalizedValue.length === 0) {
-    return undefined;
-  }
-
-  return normalizedValue;
-}
-
-function formatContextPrefix(context?: string): string {
-  if (!context) {
-    return '';
-  }
-  return `${context}${CONTEXT_SEPARATOR}`;
-}
-
-export function requireEnv(envVar: string, options: RequireEnvOptions = {}): string {
-  const value = getEnv(envVar, options);
-  if (value !== undefined) {
-    return value;
-  }
-
-  const remediation = options.remediation ?? DEFAULT_REMEDIATION_SUFFIX;
-  const contextPrefix = formatContextPrefix(options.context);
-  throw createError(
-    ErrorCodes.CONFIG_ERROR,
-    `${contextPrefix}Missing required environment variable ${envVar}. ${remediation}`,
-    { envVar, context: options.context },
-  );
-}

package/packs/software-delivery/src/config/index.ts

@@ -1,8 +0,0 @@
-// Copyright (c) 2026 Hellmai Ltd
-// SPDX-License-Identifier: LicenseRef-LumenFlow-Proprietary
-
-// Pack-local config helpers. Introduced by WU-2686 as Option 1b prep —
-// keeps the pack core-free while exposing a minimal workspace.yaml reader.
-// Extended by WU-2694 with `getConfig(cwd)` + pack-local config schema.
-export * from './workspace-reader.js';
-export * from './schemas/lumenflow-config-schema-types.js';

package/packs/software-delivery/src/config/normalize-config-keys.ts

@@ -1,9 +0,0 @@
-// Copyright (c) 2026 Hellmai Ltd
-// SPDX-License-Identifier: LicenseRef-LumenFlow-Proprietary
-
-/**
- * This utility already lives in kernel primitives, so the pack can depend on
- * it directly without routing through @lumenflow/core.
- */
-
-export * from '@lumenflow/kernel/primitives/normalize-config-keys';