@lumenflow/cli 5.5.0 → 5.7.12

package/packs/sidekick/tools/system-tools.ts

@@ -1,47 +0,0 @@
-// Copyright (c) 2026 Hellmai Ltd
-// SPDX-License-Identifier: LicenseRef-LumenFlow-Proprietary
-
-import {
-  TOOL_PERMISSIONS,
-  TOOL_SCOPE_ACCESS,
-  TOOL_SCOPE_TYPES,
-  createToolDescriptor,
-} from './types.js';
-
-const SIDEKICK_READ_SCOPE = {
-  type: TOOL_SCOPE_TYPES.PATH,
-  pattern: '.sidekick/**',
-  access: TOOL_SCOPE_ACCESS.READ,
-} as const;
-
-const SIDEKICK_WRITE_SCOPE = {
-  type: TOOL_SCOPE_TYPES.PATH,
-  pattern: '.sidekick/**',
-  access: TOOL_SCOPE_ACCESS.WRITE,
-} as const;
-
-const SYSTEM_TOOLS_ENTRY = 'tool-impl/system-tools.ts';
-
-export const sidekickInitDescriptor = createToolDescriptor({
-  name: 'sidekick:init',
-  permission: TOOL_PERMISSIONS.WRITE,
-  required_scopes: [SIDEKICK_READ_SCOPE, SIDEKICK_WRITE_SCOPE],
-  entry: SYSTEM_TOOLS_ENTRY,
-  description: 'Initialize .sidekick/ directory structure. Idempotent.',
-});
-
-export const sidekickStatusDescriptor = createToolDescriptor({
-  name: 'sidekick:status',
-  permission: TOOL_PERMISSIONS.READ,
-  required_scopes: [SIDEKICK_READ_SCOPE],
-  entry: SYSTEM_TOOLS_ENTRY,
-  description: 'Show sidekick status: store counts, initialized state, version.',
-});
-
-export const sidekickExportDescriptor = createToolDescriptor({
-  name: 'sidekick:export',
-  permission: TOOL_PERMISSIONS.READ,
-  required_scopes: [SIDEKICK_READ_SCOPE],
-  entry: SYSTEM_TOOLS_ENTRY,
-  description: 'Export all sidekick data as a JSON bundle (read-only, no file write).',
-});

package/packs/sidekick/tools/task-tools.ts

@@ -1,61 +0,0 @@
-// Copyright (c) 2026 Hellmai Ltd
-// SPDX-License-Identifier: LicenseRef-LumenFlow-Proprietary
-
-import {
-  TOOL_PERMISSIONS,
-  TOOL_SCOPE_ACCESS,
-  TOOL_SCOPE_TYPES,
-  createToolDescriptor,
-} from './types.js';
-
-const SIDEKICK_READ_SCOPE = {
-  type: TOOL_SCOPE_TYPES.PATH,
-  pattern: '.sidekick/tasks/**',
-  access: TOOL_SCOPE_ACCESS.READ,
-} as const;
-
-const SIDEKICK_WRITE_SCOPE = {
-  type: TOOL_SCOPE_TYPES.PATH,
-  pattern: '.sidekick/tasks/**',
-  access: TOOL_SCOPE_ACCESS.WRITE,
-} as const;
-
-const AUDIT_WRITE_SCOPE = {
-  type: TOOL_SCOPE_TYPES.PATH,
-  pattern: '.sidekick/audit/**',
-  access: TOOL_SCOPE_ACCESS.WRITE,
-} as const;
-
-const TASK_TOOLS_ENTRY = 'tool-impl/task-tools.ts';
-
-export const taskCreateDescriptor = createToolDescriptor({
-  name: 'task:create',
-  permission: TOOL_PERMISSIONS.WRITE,
-  required_scopes: [SIDEKICK_READ_SCOPE, SIDEKICK_WRITE_SCOPE, AUDIT_WRITE_SCOPE],
-  entry: TASK_TOOLS_ENTRY,
-  description: 'Create a new task with title, priority, due date, and tags.',
-});
-
-export const taskListDescriptor = createToolDescriptor({
-  name: 'task:list',
-  permission: TOOL_PERMISSIONS.READ,
-  required_scopes: [SIDEKICK_READ_SCOPE],
-  entry: TASK_TOOLS_ENTRY,
-  description: 'List tasks with optional filters: status, priority, tag, due_before.',
-});
-
-export const taskCompleteDescriptor = createToolDescriptor({
-  name: 'task:complete',
-  permission: TOOL_PERMISSIONS.WRITE,
-  required_scopes: [SIDEKICK_READ_SCOPE, SIDEKICK_WRITE_SCOPE, AUDIT_WRITE_SCOPE],
-  entry: TASK_TOOLS_ENTRY,
-  description: 'Mark a task as complete. Supports dry_run.',
-});
-
-export const taskScheduleDescriptor = createToolDescriptor({
-  name: 'task:schedule',
-  permission: TOOL_PERMISSIONS.WRITE,
-  required_scopes: [SIDEKICK_READ_SCOPE, SIDEKICK_WRITE_SCOPE, AUDIT_WRITE_SCOPE],
-  entry: TASK_TOOLS_ENTRY,
-  description: 'Set or update a task due date or cron schedule.',
-});

package/packs/sidekick/tools/types.ts

@@ -1,57 +0,0 @@
-// Copyright (c) 2026 Hellmai Ltd
-// SPDX-License-Identifier: LicenseRef-LumenFlow-Proprietary
-
-import { SIDEKICK_DOMAIN, SIDEKICK_PACK_ID, SIDEKICK_PACK_VERSION } from '../constants.js';
-
-export const TOOL_SCOPE_TYPES = {
-  PATH: 'path',
-} as const;
-
-export const TOOL_SCOPE_ACCESS = {
-  READ: 'read',
-  WRITE: 'write',
-} as const;
-
-export const TOOL_PERMISSIONS = {
-  READ: 'read',
-  WRITE: 'write',
-  ADMIN: 'admin',
-} as const;
-
-export type ToolScopeType = (typeof TOOL_SCOPE_TYPES)[keyof typeof TOOL_SCOPE_TYPES];
-export type ToolScopeAccess = (typeof TOOL_SCOPE_ACCESS)[keyof typeof TOOL_SCOPE_ACCESS];
-export type ToolPermission = (typeof TOOL_PERMISSIONS)[keyof typeof TOOL_PERMISSIONS];
-
-export interface PathScope {
-  type: ToolScopeType;
-  pattern: string;
-  access: ToolScopeAccess;
-}
-
-export interface ToolDescriptor {
-  name: string;
-  domain: typeof SIDEKICK_DOMAIN;
-  version: typeof SIDEKICK_PACK_VERSION;
-  permission: ToolPermission;
-  required_scopes: PathScope[];
-  entry: string;
-  description: string;
-  pack: typeof SIDEKICK_PACK_ID;
-}
-
-export interface ToolDescriptorInput {
-  name: ToolDescriptor['name'];
-  permission: ToolDescriptor['permission'];
-  required_scopes: ToolDescriptor['required_scopes'];
-  entry: ToolDescriptor['entry'];
-  description: ToolDescriptor['description'];
-}
-
-export function createToolDescriptor(input: ToolDescriptorInput): ToolDescriptor {
-  return {
-    ...input,
-    domain: SIDEKICK_DOMAIN,
-    version: SIDEKICK_PACK_VERSION,
-    pack: SIDEKICK_PACK_ID,
-  };
-}

package/packs/sidekick/vitest.config.ts

@@ -1,11 +0,0 @@
-import { defineConfig } from 'vitest/config';
-
-export default defineConfig({
-  test: {
-    globals: true,
-    environment: 'node',
-    include: ['__tests__/**/*.test.ts', '**/*.spec.ts'],
-    exclude: ['**/node_modules/**', '**/dist/**'],
-    passWithNoTests: false,
-  },
-});

package/packs/software-delivery/constants.ts

@@ -1,10 +0,0 @@
-// Copyright (c) 2026 Hellmai Ltd
-// SPDX-License-Identifier: LicenseRef-LumenFlow-Proprietary
-
-export const SOFTWARE_DELIVERY_PACK_ID = 'software-delivery' as const;
-export const SOFTWARE_DELIVERY_PACK_VERSION = '0.1.0' as const;
-export const SOFTWARE_DELIVERY_DOMAIN = SOFTWARE_DELIVERY_PACK_ID;
-export const SOFTWARE_DELIVERY_POLICY_ID_PREFIX = `${SOFTWARE_DELIVERY_PACK_ID}.gate` as const;
-export const SOFTWARE_DELIVERY_MANIFEST_FILE_NAME = 'manifest.yaml' as const;
-export const SHA256_ALGORITHM = 'sha256' as const;
-export const UTF8_ENCODING = 'utf8' as const;

package/packs/software-delivery/extensions.ts

@@ -1,140 +0,0 @@
-// Copyright (c) 2026 Hellmai Ltd
-// SPDX-License-Identifier: LicenseRef-LumenFlow-Proprietary
-
-import { SOFTWARE_DELIVERY_DOMAIN } from './constants.js';
-
-export const SOFTWARE_DELIVERY_EXTENSION_KEY = 'software_delivery';
-export const SOFTWARE_DELIVERY_EXPOSURES = ['ui', 'api', 'backend-only', 'documentation'] as const;
-
-interface Parser<T> {
-  parse(input: unknown): T;
-}
-
-export interface SoftwareDeliveryTests {
-  unit: string[];
-  e2e: string[];
-  manual: string[];
-}
-
-export interface SoftwareDeliveryTaskExtensions {
-  code_paths: string[];
-  tests: SoftwareDeliveryTests;
-  exposure: (typeof SOFTWARE_DELIVERY_EXPOSURES)[number];
-  worktree: string;
-  branch: string;
-}
-
-export interface SoftwareDeliveryTask {
-  domain: typeof SOFTWARE_DELIVERY_DOMAIN;
-  extensions: Record<string, unknown> & {
-    [SOFTWARE_DELIVERY_EXTENSION_KEY]: SoftwareDeliveryTaskExtensions;
-  };
-}
-
-function asRecord(input: unknown, label: string): Record<string, unknown> {
-  if (!input || typeof input !== 'object' || Array.isArray(input)) {
-    throw new Error(`${label} must be an object.`);
-  }
-  return input as Record<string, unknown>;
-}
-
-function assertOnlyKeys(
-  record: Record<string, unknown>,
-  allowedKeys: readonly string[],
-  label: string,
-): void {
-  const allowed = new Set(allowedKeys);
-  for (const key of Object.keys(record)) {
-    if (!allowed.has(key)) {
-      throw new Error(`${label} has unrecognized key "${key}".`);
-    }
-  }
-}
-
-function parseNonEmptyString(value: unknown, label: string): string {
-  if (typeof value !== 'string' || value.trim().length === 0) {
-    throw new Error(`${label} must be a non-empty string.`);
-  }
-  return value;
-}
-
-function parseStringArray(value: unknown, label: string): string[] {
-  if (!Array.isArray(value)) {
-    throw new Error(`${label} must be an array.`);
-  }
-  return value.map((entry, index) => parseNonEmptyString(entry, `${label}[${index}]`));
-}
-
-function parseTests(input: unknown): SoftwareDeliveryTests {
-  const tests = asRecord(input, 'tests');
-  assertOnlyKeys(tests, ['unit', 'e2e', 'manual'], 'tests');
-  return {
-    unit: parseStringArray(tests.unit ?? [], 'tests.unit'),
-    e2e: parseStringArray(tests.e2e ?? [], 'tests.e2e'),
-    manual: parseStringArray(tests.manual ?? [], 'tests.manual'),
-  };
-}
-
-const ExposureSet = new Set<string>(SOFTWARE_DELIVERY_EXPOSURES);
-
-export const SoftwareDeliveryTaskExtensionsSchema: Parser<SoftwareDeliveryTaskExtensions> = {
-  parse(input: unknown): SoftwareDeliveryTaskExtensions {
-    const extension = asRecord(input, 'software delivery extension');
-    assertOnlyKeys(
-      extension,
-      ['code_paths', 'tests', 'exposure', 'worktree', 'branch'],
-      'software delivery extension',
-    );
-
-    const exposure = parseNonEmptyString(extension.exposure, 'exposure');
-    if (!ExposureSet.has(exposure)) {
-      throw new Error(`exposure must be one of: ${SOFTWARE_DELIVERY_EXPOSURES.join(', ')}`);
-    }
-
-    return {
-      code_paths: parseStringArray(extension.code_paths, 'code_paths'),
-      tests: parseTests(extension.tests),
-      exposure: exposure as (typeof SOFTWARE_DELIVERY_EXPOSURES)[number],
-      worktree: parseNonEmptyString(extension.worktree, 'worktree'),
-      branch: parseNonEmptyString(extension.branch, 'branch'),
-    };
-  },
-};
-
-export const TaskExtensionsOpaqueRecordSchema: Parser<Record<string, unknown>> = {
-  parse(input: unknown): Record<string, unknown> {
-    return asRecord(input, 'extensions');
-  },
-};
-
-export function extractSoftwareDeliveryExtensions(
-  extensions: Record<string, unknown> | undefined,
-): SoftwareDeliveryTaskExtensions {
-  const parsedExtensions = TaskExtensionsOpaqueRecordSchema.parse(extensions ?? {});
-  return SoftwareDeliveryTaskExtensionsSchema.parse(
-    parsedExtensions[SOFTWARE_DELIVERY_EXTENSION_KEY],
-  );
-}
-
-export const SoftwareDeliveryTaskSchema: Parser<SoftwareDeliveryTask> = {
-  parse(input: unknown): SoftwareDeliveryTask {
-    const task = asRecord(input, 'task');
-
-    if (task.domain !== SOFTWARE_DELIVERY_DOMAIN) {
-      throw new Error(`task.domain must be "${SOFTWARE_DELIVERY_DOMAIN}".`);
-    }
-
-    const parsedExtensions = TaskExtensionsOpaqueRecordSchema.parse(task.extensions);
-    const parsedSoftwareDeliveryExtensions = SoftwareDeliveryTaskExtensionsSchema.parse(
-      parsedExtensions[SOFTWARE_DELIVERY_EXTENSION_KEY],
-    );
-
-    return {
-      domain: SOFTWARE_DELIVERY_DOMAIN,
-      extensions: {
-        ...parsedExtensions,
-        [SOFTWARE_DELIVERY_EXTENSION_KEY]: parsedSoftwareDeliveryExtensions,
-      },
-    };
-  },
-};

package/packs/software-delivery/gate-policies.ts

@@ -1,134 +0,0 @@
-// Copyright (c) 2026 Hellmai Ltd
-// SPDX-License-Identifier: LicenseRef-LumenFlow-Proprietary
-
-import { SOFTWARE_DELIVERY_PACK_ID, SOFTWARE_DELIVERY_POLICY_ID_PREFIX } from './constants.js';
-
-export const SOFTWARE_DELIVERY_GATE_NAMES = [
-  'format',
-  'lint',
-  'typecheck',
-  'test',
-  'coverage',
-] as const;
-
-export type SoftwareDeliveryGateName = (typeof SOFTWARE_DELIVERY_GATE_NAMES)[number];
-
-export interface PolicyProvider {
-  id: string;
-  gate: SoftwareDeliveryGateName;
-  trigger: 'on_completion';
-  command: string;
-}
-
-export interface CompletionPolicyContext {
-  trigger: 'on_completion';
-  run_id: string;
-  task_id: string;
-  gate: SoftwareDeliveryGateName;
-  pack_id: typeof SOFTWARE_DELIVERY_PACK_ID;
-}
-
-export interface CompletionPolicyEvaluation {
-  decision: 'allow' | 'deny';
-  decisions: Array<{
-    policy_id: string;
-    decision: 'allow' | 'deny';
-    reason?: string;
-  }>;
-  warnings: string[];
-}
-
-export interface CompletionPolicyEngine {
-  evaluate(context: CompletionPolicyContext): Promise<CompletionPolicyEvaluation>;
-}
-
-export interface CompletionPolicyExecution {
-  ok: boolean;
-}
-
-export interface CompletionPolicyRunResult {
-  gate: SoftwareDeliveryGateName;
-  policy_id: string;
-  decision: 'allow' | 'deny';
-  command: string;
-  executed: boolean;
-  ok: boolean;
-}
-
-const SOFTWARE_DELIVERY_GATE_COMMANDS: Record<SoftwareDeliveryGateName, string> = {
-  format: 'pnpm format:check',
-  lint: 'pnpm lint',
-  typecheck: 'pnpm typecheck',
-  test: 'pnpm turbo run test',
-  coverage: 'pnpm vitest run --coverage',
-};
-
-export const SOFTWARE_DELIVERY_GATE_POLICIES: readonly PolicyProvider[] =
-  SOFTWARE_DELIVERY_GATE_NAMES.map((gate) => ({
-    id: `${SOFTWARE_DELIVERY_POLICY_ID_PREFIX}.${gate}`,
-    gate,
-    trigger: 'on_completion',
-    command: SOFTWARE_DELIVERY_GATE_COMMANDS[gate],
-  }));
-
-export const SOFTWARE_DELIVERY_STATE_ALIASES = {
-  active: 'in_progress',
-} as const;
-
-export function resolveSoftwareDeliveryStateAlias(
-  state: string,
-  aliases: Record<string, string> = SOFTWARE_DELIVERY_STATE_ALIASES,
-): string {
-  return aliases[state] ?? state;
-}
-
-export async function runCompletionGatePolicies(options: {
-  engine: CompletionPolicyEngine;
-  runId: string;
-  taskId: string;
-  providers?: readonly PolicyProvider[];
-  executePolicy?: (provider: PolicyProvider) => Promise<CompletionPolicyExecution>;
-}): Promise<CompletionPolicyRunResult[]> {
-  const providers = options.providers ?? SOFTWARE_DELIVERY_GATE_POLICIES;
-  const executePolicy =
-    options.executePolicy ??
-    (async () => ({
-      ok: true,
-    }));
-
-  const results: CompletionPolicyRunResult[] = [];
-
-  for (const provider of providers) {
-    const evaluation = await options.engine.evaluate({
-      trigger: provider.trigger,
-      run_id: options.runId,
-      task_id: options.taskId,
-      gate: provider.gate,
-      pack_id: SOFTWARE_DELIVERY_PACK_ID,
-    });
-
-    if (evaluation.decision === 'deny') {
-      results.push({
-        gate: provider.gate,
-        policy_id: provider.id,
-        decision: 'deny',
-        command: provider.command,
-        executed: false,
-        ok: false,
-      });
-      continue;
-    }
-
-    const execution = await executePolicy(provider);
-    results.push({
-      gate: provider.gate,
-      policy_id: provider.id,
-      decision: 'allow',
-      command: provider.command,
-      executed: true,
-      ok: execution.ok,
-    });
-  }
-
-  return results;
-}

package/packs/software-delivery/index.ts

@@ -1,8 +0,0 @@
-// Copyright (c) 2026 Hellmai Ltd
-// SPDX-License-Identifier: LicenseRef-LumenFlow-Proprietary
-
-export * from './constants.js';
-export * from './extensions.js';
-export * from './gate-policies.js';
-export * from './manifest.js';
-export * from './pack-registration.js';