@lumenflow/cli 3.19.0 → 3.21.0

package/packs/sidekick/manifest-schema.ts

@@ -2,23 +2,18 @@
 // SPDX-License-Identifier: AGPL-3.0-only
 
 import {
-  TOOL_PERMISSIONS,
-  TOOL_SCOPE_ACCESS,
-  TOOL_SCOPE_TYPES,
-  type PathScope,
-  type ToolPermission,
-} from './tools/types.js';
+  DomainPackManifestSchema,
+  POLICY_TRIGGERS,
+  type DomainPackManifest,
+  type DomainPackTool,
+} from '@lumenflow/kernel';
+import type { PathScope, ToolPermission } from './tools/types.js';
 
 interface Parser<T> {
   parse(input: unknown): T;
 }
 
-export const MANIFEST_POLICY_TRIGGERS = {
-  ON_TOOL_REQUEST: 'on_tool_request',
-  ON_CLAIM: 'on_claim',
-  ON_COMPLETION: 'on_completion',
-  ON_EVIDENCE_ADDED: 'on_evidence_added',
-} as const;
+export const MANIFEST_POLICY_TRIGGERS = POLICY_TRIGGERS;
 
 export type ManifestPolicyTrigger =
   (typeof MANIFEST_POLICY_TRIGGERS)[keyof typeof MANIFEST_POLICY_TRIGGERS];
@@ -26,237 +21,29 @@ export type ManifestPolicyTrigger =
 export const MANIFEST_POLICY_DECISIONS = {
   ALLOW: 'allow',
   DENY: 'deny',
+  APPROVAL_REQUIRED: 'approval_required',
 } as const;
 
 export type ManifestPolicyDecision =
   (typeof MANIFEST_POLICY_DECISIONS)[keyof typeof MANIFEST_POLICY_DECISIONS];
 
-export interface SidekickManifestTool {
-  name: string;
-  entry: string;
+export interface SidekickManifestTool extends Omit<
+  DomainPackTool,
+  'permission' | 'required_scopes'
+> {
   permission: ToolPermission;
   required_scopes: PathScope[];
-  input_schema?: Record<string, unknown>;
-  output_schema?: Record<string, unknown>;
-  internal_only?: boolean;
 }
 
-export interface SidekickManifestPolicy {
-  id: string;
-  trigger: ManifestPolicyTrigger;
-  decision: ManifestPolicyDecision;
-  reason?: string;
-}
+export type SidekickManifestPolicy = DomainPackManifest['policies'][number];
 
-export interface SidekickPackManifest {
-  id: string;
-  version: string;
-  config_key?: string;
-  config_schema?: string;
-  task_types: string[];
+export interface SidekickPackManifest extends Omit<DomainPackManifest, 'tools' | 'policies'> {
   tools: SidekickManifestTool[];
   policies: SidekickManifestPolicy[];
-  evidence_types: string[];
-  state_aliases: Record<string, string>;
-  lane_templates: Array<{ id: string }>;
-}
-
-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 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 parseJsonSchemaObject(value: unknown, label: string): Record<string, unknown> {
-  return asRecord(value, label);
-}
-
-function isSemver(value: string): boolean {
-  let core = value;
-  const prereleaseIndex = core.indexOf('-');
-  if (prereleaseIndex >= 0) {
-    core = core.slice(0, prereleaseIndex);
-  }
-  const metadataIndex = core.indexOf('+');
-  if (metadataIndex >= 0) {
-    core = core.slice(0, metadataIndex);
-  }
-
-  const parts = core.split('.');
-  if (parts.length !== 3) {
-    return false;
-  }
-
-  return parts.every(
-    (part) => part.length > 0 && [...part].every((char) => char >= '0' && char <= '9'),
-  );
-}
-
-const ALLOWED_POLICY_TRIGGERS = new Set<string>(Object.values(MANIFEST_POLICY_TRIGGERS));
-const ALLOWED_POLICY_DECISIONS = new Set<string>(Object.values(MANIFEST_POLICY_DECISIONS));
-const ALLOWED_TOOL_PERMISSIONS = new Set<string>(Object.values(TOOL_PERMISSIONS));
-
-function parsePathScope(input: unknown, label: string): PathScope {
-  const scope = asRecord(input, label);
-  const type = parseNonEmptyString(scope.type, `${label}.type`);
-  const pattern = parseNonEmptyString(scope.pattern, `${label}.pattern`);
-  const access = parseNonEmptyString(scope.access, `${label}.access`);
-
-  if (type !== TOOL_SCOPE_TYPES.PATH) {
-    throw new Error(`${label}.type must be "${TOOL_SCOPE_TYPES.PATH}".`);
-  }
-  if (access !== TOOL_SCOPE_ACCESS.READ && access !== TOOL_SCOPE_ACCESS.WRITE) {
-    throw new Error(
-      `${label}.access must be "${TOOL_SCOPE_ACCESS.READ}" or "${TOOL_SCOPE_ACCESS.WRITE}".`,
-    );
-  }
-
-  return {
-    type: TOOL_SCOPE_TYPES.PATH,
-    pattern,
-    access,
-  };
-}
-
-function parseRequiredScopes(value: unknown, label: string): PathScope[] {
-  if (!Array.isArray(value) || value.length === 0) {
-    throw new Error(`${label} must be a non-empty array.`);
-  }
-  return value.map((entry, index) => parsePathScope(entry, `${label}[${index}]`));
-}
-
-function parsePolicy(input: unknown, index: number): SidekickManifestPolicy {
-  const policy = asRecord(input, `policies[${index}]`);
-  const trigger = parseNonEmptyString(policy.trigger, `policies[${index}].trigger`);
-  const decision = parseNonEmptyString(policy.decision, `policies[${index}].decision`);
-
-  if (!ALLOWED_POLICY_TRIGGERS.has(trigger)) {
-    throw new Error(`policies[${index}].trigger is invalid.`);
-  }
-  if (!ALLOWED_POLICY_DECISIONS.has(decision)) {
-    throw new Error(`policies[${index}].decision is invalid.`);
-  }
-
-  return {
-    id: parseNonEmptyString(policy.id, `policies[${index}].id`),
-    trigger: trigger as ManifestPolicyTrigger,
-    decision: decision as ManifestPolicyDecision,
-    reason:
-      policy.reason === undefined
-        ? undefined
-        : parseNonEmptyString(policy.reason, `policies[${index}].reason`),
-  };
-}
-
-function parseTool(input: unknown, index: number): SidekickManifestTool {
-  const tool = asRecord(input, `tools[${index}]`);
-  const permission =
-    tool.permission === undefined
-      ? TOOL_PERMISSIONS.READ
-      : parseNonEmptyString(tool.permission, `tools[${index}].permission`);
-
-  if (!ALLOWED_TOOL_PERMISSIONS.has(permission)) {
-    throw new Error(`tools[${index}].permission is invalid.`);
-  }
-
-  return {
-    name: parseNonEmptyString(tool.name, `tools[${index}].name`),
-    entry: parseNonEmptyString(tool.entry, `tools[${index}].entry`),
-    permission: permission as ToolPermission,
-    required_scopes: parseRequiredScopes(tool.required_scopes, `tools[${index}].required_scopes`),
-    input_schema:
-      tool.input_schema === undefined
-        ? undefined
-        : parseJsonSchemaObject(tool.input_schema, `tools[${index}].input_schema`),
-    output_schema:
-      tool.output_schema === undefined
-        ? undefined
-        : parseJsonSchemaObject(tool.output_schema, `tools[${index}].output_schema`),
-    internal_only:
-      tool.internal_only === undefined
-        ? undefined
-        : (() => {
-            if (typeof tool.internal_only !== 'boolean') {
-              throw new Error(`tools[${index}].internal_only must be boolean.`);
-            }
-            return tool.internal_only;
-          })(),
-  };
-}
-
-function parseStateAliases(input: unknown): Record<string, string> {
-  const aliases = asRecord(input ?? {}, 'state_aliases');
-  const parsed: Record<string, string> = {};
-  for (const [key, value] of Object.entries(aliases)) {
-    parsed[parseNonEmptyString(key, 'state_aliases key')] = parseNonEmptyString(
-      value,
-      `state_aliases.${key}`,
-    );
-  }
-  return parsed;
 }
 
 export const SidekickManifestSchema: Parser<SidekickPackManifest> = {
   parse(input: unknown): SidekickPackManifest {
-    const manifest = asRecord(input, 'manifest');
-    const version = parseNonEmptyString(manifest.version, 'version');
-    if (!isSemver(version)) {
-      throw new Error('version must be semver.');
-    }
-
-    const taskTypes = parseStringArray(manifest.task_types, 'task_types');
-    if (taskTypes.length === 0) {
-      throw new Error('task_types must include at least one item.');
-    }
-
-    const toolsValue = manifest.tools ?? [];
-    if (!Array.isArray(toolsValue)) {
-      throw new Error('tools must be an array.');
-    }
-    const policiesValue = manifest.policies ?? [];
-    if (!Array.isArray(policiesValue)) {
-      throw new Error('policies must be an array.');
-    }
-    const laneTemplatesValue = manifest.lane_templates ?? [];
-    if (!Array.isArray(laneTemplatesValue)) {
-      throw new Error('lane_templates must be an array.');
-    }
-
-    return {
-      id: parseNonEmptyString(manifest.id, 'id'),
-      version,
-      config_key:
-        manifest.config_key === undefined
-          ? undefined
-          : parseNonEmptyString(manifest.config_key, 'config_key'),
-      config_schema:
-        manifest.config_schema === undefined
-          ? undefined
-          : parseNonEmptyString(manifest.config_schema, 'config_schema'),
-      task_types: taskTypes,
-      tools: toolsValue.map((tool, index) => parseTool(tool, index)),
-      policies: policiesValue.map((policy, index) => parsePolicy(policy, index)),
-      evidence_types: parseStringArray(manifest.evidence_types ?? [], 'evidence_types'),
-      state_aliases: parseStateAliases(manifest.state_aliases),
-      lane_templates: laneTemplatesValue.map((laneTemplate, index) => {
-        const entry = asRecord(laneTemplate, `lane_templates[${index}]`);
-        return { id: parseNonEmptyString(entry.id, `lane_templates[${index}].id`) };
-      }),
-    };
+    return DomainPackManifestSchema.parse(input) as SidekickPackManifest;
   },
 };

package/packs/sidekick/manifest.ts

@@ -34,26 +34,33 @@ const SIDEKICK_SCOPE_WRITE: PathScope = {
 };
 
 // ---------------------------------------------------------------------------
-// 16-tool contract (per strategy: 5 groups)
+// Sidekick tool contract
 // ---------------------------------------------------------------------------
 
 const TOOL_PERMISSIONS_MAP = {
-  // Task tools (4)
+  // Task tools (6)
   'task:create': TOOL_PERMISSIONS.WRITE,
   'task:list': TOOL_PERMISSIONS.READ,
+  'task:update': TOOL_PERMISSIONS.WRITE,
+  'task:cancel': TOOL_PERMISSIONS.ADMIN,
   'task:complete': TOOL_PERMISSIONS.WRITE,
   'task:schedule': TOOL_PERMISSIONS.WRITE,
-  // Memory tools (3)
+  // Memory tools (4)
   'memory:store': TOOL_PERMISSIONS.WRITE,
   'memory:recall': TOOL_PERMISSIONS.READ,
-  'memory:forget': TOOL_PERMISSIONS.WRITE,
-  // Channel tools (3)
+  'memory:update': TOOL_PERMISSIONS.WRITE,
+  'memory:forget': TOOL_PERMISSIONS.ADMIN,
+  // Channel tools (5)
   'channel:configure': TOOL_PERMISSIONS.WRITE,
+  'channel:list': TOOL_PERMISSIONS.READ,
+  'channel:delete': TOOL_PERMISSIONS.ADMIN,
   'channel:send': TOOL_PERMISSIONS.WRITE,
   'channel:receive': TOOL_PERMISSIONS.READ,
-  // Routine tools (3)
+  // Routine tools (5)
   'routine:create': TOOL_PERMISSIONS.WRITE,
   'routine:list': TOOL_PERMISSIONS.READ,
+  'routine:update': TOOL_PERMISSIONS.WRITE,
+  'routine:delete': TOOL_PERMISSIONS.ADMIN,
   'routine:run': TOOL_PERMISSIONS.READ, // plan-only, no execution
   // System tools (3)
   'sidekick:init': TOOL_PERMISSIONS.WRITE,
@@ -68,20 +75,28 @@ const MEMORY_TOOLS_ENTRY = 'tool-impl/memory-tools.ts';
 const CHANNEL_TOOLS_ENTRY = 'tool-impl/channel-tools.ts';
 const ROUTINE_TOOLS_ENTRY = 'tool-impl/routine-tools.ts';
 const SYSTEM_TOOLS_ENTRY = 'tool-impl/system-tools.ts';
+const POLICY_FACTORY_ENTRY = 'policy-factory.ts#createSidekickPolicyFactory';
 
 const TOOL_ENTRIES: Record<SidekickToolName, string> = {
   'task:create': TASK_TOOLS_ENTRY,
   'task:list': TASK_TOOLS_ENTRY,
+  'task:update': TASK_TOOLS_ENTRY,
+  'task:cancel': TASK_TOOLS_ENTRY,
   'task:complete': TASK_TOOLS_ENTRY,
   'task:schedule': TASK_TOOLS_ENTRY,
   'memory:store': MEMORY_TOOLS_ENTRY,
   'memory:recall': MEMORY_TOOLS_ENTRY,
+  'memory:update': MEMORY_TOOLS_ENTRY,
   'memory:forget': MEMORY_TOOLS_ENTRY,
   'channel:configure': CHANNEL_TOOLS_ENTRY,
+  'channel:list': CHANNEL_TOOLS_ENTRY,
+  'channel:delete': CHANNEL_TOOLS_ENTRY,
   'channel:send': CHANNEL_TOOLS_ENTRY,
   'channel:receive': CHANNEL_TOOLS_ENTRY,
   'routine:create': ROUTINE_TOOLS_ENTRY,
   'routine:list': ROUTINE_TOOLS_ENTRY,
+  'routine:update': ROUTINE_TOOLS_ENTRY,
+  'routine:delete': ROUTINE_TOOLS_ENTRY,
   'routine:run': ROUTINE_TOOLS_ENTRY,
   'sidekick:init': SYSTEM_TOOLS_ENTRY,
   'sidekick:status': SYSTEM_TOOLS_ENTRY,
@@ -109,7 +124,7 @@ const TOOL_INPUT_SCHEMAS: Record<SidekickToolName, Record<string, unknown>> = {
   'task:list': {
     type: 'object',
     properties: {
-      status: { type: 'string', enum: ['pending', 'done'] },
+      status: { type: 'string', enum: ['pending', 'done', 'canceled'] },
       priority: { type: 'string', enum: ['P0', 'P1', 'P2', 'P3'] },
       tags: { type: 'array', items: { type: 'string' } },
       search: { type: 'string' },
@@ -118,6 +133,30 @@ const TOOL_INPUT_SCHEMAS: Record<SidekickToolName, Record<string, unknown>> = {
     },
     additionalProperties: false,
   },
+  'task:update': {
+    type: 'object',
+    properties: {
+      id: { type: 'string', minLength: 1 },
+      title: { type: 'string', minLength: 1 },
+      description: { type: 'string' },
+      priority: { type: 'string', enum: ['P0', 'P1', 'P2', 'P3'] },
+      tags: { type: 'array', items: { type: 'string' } },
+      due_at: { type: 'string' },
+      cron: { type: 'string' },
+      dry_run: { type: 'boolean' },
+    },
+    required: ['id'],
+    additionalProperties: false,
+  },
+  'task:cancel': {
+    type: 'object',
+    properties: {
+      id: { type: 'string', minLength: 1 },
+      dry_run: { type: 'boolean' },
+    },
+    required: ['id'],
+    additionalProperties: false,
+  },
   'task:complete': {
     type: 'object',
     properties: {
@@ -169,6 +208,18 @@ const TOOL_INPUT_SCHEMAS: Record<SidekickToolName, Record<string, unknown>> = {
     required: ['id'],
     additionalProperties: false,
   },
+  'memory:update': {
+    type: 'object',
+    properties: {
+      id: { type: 'string', minLength: 1 },
+      type: { type: 'string', enum: ['fact', 'preference', 'note', 'snippet'] },
+      content: { type: 'string', minLength: 1 },
+      tags: { type: 'array', items: { type: 'string' } },
+      dry_run: { type: 'boolean' },
+    },
+    required: ['id'],
+    additionalProperties: false,
+  },
   'channel:configure': {
     type: 'object',
     properties: {
@@ -179,6 +230,20 @@ const TOOL_INPUT_SCHEMAS: Record<SidekickToolName, Record<string, unknown>> = {
     required: ['name'],
     additionalProperties: false,
   },
+  'channel:list': {
+    type: 'object',
+    properties: {},
+    additionalProperties: false,
+  },
+  'channel:delete': {
+    type: 'object',
+    properties: {
+      id: { type: 'string', minLength: 1 },
+      dry_run: { type: 'boolean' },
+    },
+    required: ['id'],
+    additionalProperties: false,
+  },
   'channel:send': {
     type: 'object',
     properties: {
@@ -236,6 +301,40 @@ const TOOL_INPUT_SCHEMAS: Record<SidekickToolName, Record<string, unknown>> = {
     },
     additionalProperties: false,
   },
+  'routine:update': {
+    type: 'object',
+    properties: {
+      id: { type: 'string', minLength: 1 },
+      name: { type: 'string', minLength: 1 },
+      steps: {
+        type: 'array',
+        minItems: 1,
+        items: {
+          type: 'object',
+          properties: {
+            tool: { type: 'string', minLength: 1 },
+            input: { type: 'object', additionalProperties: true },
+          },
+          required: ['tool'],
+          additionalProperties: false,
+        },
+      },
+      cron: { type: 'string' },
+      enabled: { type: 'boolean' },
+      dry_run: { type: 'boolean' },
+    },
+    required: ['id'],
+    additionalProperties: false,
+  },
+  'routine:delete': {
+    type: 'object',
+    properties: {
+      id: { type: 'string', minLength: 1 },
+      dry_run: { type: 'boolean' },
+    },
+    required: ['id'],
+    additionalProperties: false,
+  },
   'routine:run': {
     type: 'object',
     properties: {
@@ -310,6 +409,7 @@ const SIDEKICK_MANIFEST_TEMPLATE = {
   id: SIDEKICK_PACK_ID,
   version: SIDEKICK_PACK_VERSION,
   config_key: SIDEKICK_PACK_ID,
+  policy_factory: POLICY_FACTORY_ENTRY,
   task_types: ['sidekick'],
   tools: SIDEKICK_TOOL_NAMES.map((name) => buildTool(name)),
   policies: [