agentic-orchestrator 0.1.2 → 0.1.4

package/apps/control-plane/src/cli/init-command-handler.ts

@@ -0,0 +1,609 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { execFile } from 'node:child_process';
+import { createInterface } from 'node:readline/promises';
+import { promisify } from 'node:util';
+import { stdin as input, stdout as output } from 'node:process';
+import { fileURLToPath } from 'node:url';
+import YAML from 'yaml';
+import { SchemaRegistry } from '../core/schemas.js';
+
+const execFileAsync = promisify(execFile);
+const MODULE_DIR = path.dirname(fileURLToPath(import.meta.url));
+const TEMPLATE_ROOT = path.resolve(MODULE_DIR, '../../../../agentic/orchestrator');
+
+export interface InitOptions {
+  auto?: boolean;
+  force?: boolean;
+}
+
+type TestFramework = 'vitest' | 'jest' | 'pytest' | 'maven' | 'gradle';
+
+interface PromptSession {
+  question(query: string): Promise<string>;
+  close(): void;
+}
+
+interface GitContext {
+  remoteUrl: string | null;
+  defaultBranch: string;
+}
+
+interface WizardConfig {
+  baseBranch: string;
+  maxParallelGateRuns: number;
+  dashboardPort: number;
+  framework: TestFramework;
+  notifications: {
+    desktop: boolean;
+    slack: boolean;
+    webhook: boolean;
+    slackWebhook: string;
+    webhookUrl: string;
+  };
+}
+
+export interface InitCommandResult {
+  ok: true;
+  data: {
+    command: 'init';
+    created: string[];
+    updated: string[];
+    skipped: string[];
+    validation_warnings: string[];
+    next_steps: string[];
+  };
+}
+
+function createPromptSession(): PromptSession {
+  return createInterface({ input, output });
+}
+
+async function detectGitContext(repoRoot: string): Promise<GitContext> {
+  let remoteUrl: string | null = null;
+  try {
+    const gitConfig = await fs.readFile(path.join(repoRoot, '.git', 'config'), 'utf8');
+    const sections = gitConfig.split(/\n(?=\[)/);
+    for (const section of sections) {
+      if (/^\[remote "origin"]/.test(section)) {
+        const urlMatch = /\s+url\s*=\s*(.+)/.exec(section);
+        if (urlMatch) {
+          remoteUrl = urlMatch[1].trim();
+        }
+        break;
+      }
+    }
+  } catch {
+    // not a git repo or no .git/config
+  }
+
+  let defaultBranch = 'main';
+  try {
+    const { stdout } = await execFileAsync(
+      'git',
+      ['-C', repoRoot, 'symbolic-ref', 'refs/remotes/origin/HEAD', '--short'],
+      { timeout: 3000 }
+    );
+    const ref = stdout.trim();
+    const parts = ref.split('/');
+    defaultBranch = parts[parts.length - 1] ?? 'main';
+  } catch {
+    // use default
+  }
+
+  return { remoteUrl, defaultBranch };
+}
+
+async function detectTestFramework(repoRoot: string): Promise<TestFramework> {
+  try {
+    const content = await fs.readFile(path.join(repoRoot, 'package.json'), 'utf8');
+    const pkg = JSON.parse(content) as Record<string, unknown>;
+    const deps: Record<string, unknown> = {
+      ...(typeof pkg.dependencies === 'object' && pkg.dependencies !== null
+        ? (pkg.dependencies as Record<string, unknown>)
+        : {}),
+      ...(typeof pkg.devDependencies === 'object' && pkg.devDependencies !== null
+        ? (pkg.devDependencies as Record<string, unknown>)
+        : {})
+    };
+    if ('vitest' in deps) {
+      return 'vitest';
+    }
+    if ('jest' in deps) {
+      return 'jest';
+    }
+  } catch {
+    // no package.json
+  }
+
+  const buildFileChecks: Array<[string, TestFramework]> = [
+    ['setup.py', 'pytest'],
+    ['pyproject.toml', 'pytest'],
+    ['pom.xml', 'maven'],
+    ['build.gradle', 'gradle'],
+    ['build.gradle.kts', 'gradle']
+  ];
+
+  for (const [file, framework] of buildFileChecks) {
+    try {
+      await fs.access(path.join(repoRoot, file));
+      return framework;
+    } catch {
+      // continue
+    }
+  }
+
+  return 'vitest';
+}
+
+function buildGateCommands(framework: TestFramework): { test: string[]; testWithCoverage: string[] } {
+  switch (framework) {
+    case 'jest':
+      return { test: ['npx', 'jest'], testWithCoverage: ['npx', 'jest', '--coverage'] };
+    case 'pytest':
+      return { test: ['pytest'], testWithCoverage: ['pytest', '--cov'] };
+    case 'maven':
+      return { test: ['mvn', 'test'], testWithCoverage: ['mvn', 'verify'] };
+    case 'gradle':
+      return { test: ['./gradlew', 'test'], testWithCoverage: ['./gradlew', 'check'] };
+    default:
+      return { test: ['npx', 'vitest', 'run'], testWithCoverage: ['npx', 'vitest', 'run', '--coverage'] };
+  }
+}
+
+function yamlList(items: string[]): string {
+  return items.map((item) => `"${item}"`).join(', ');
+}
+
+function escapeYamlString(value: string): string {
+  return value.replace(/\\/g, '\\\\').replace(/"/g, '\\"');
+}
+
+function generatePolicyYaml(context: GitContext, wizard: WizardConfig): string {
+  const notificationsEnabled = wizard.notifications.desktop || wizard.notifications.slack || wizard.notifications.webhook;
+  return `version: 1
+commit_policy:
+  allow_commit: false
+  allow_merge: false
+patch_policy:
+  enforce_plan: true
+  enforce_allowed_areas: true
+locks:
+  resources:
+    - openapi
+    - events
+    - db_migrations
+  contract_to_resource:
+    openapi: openapi
+    events: events
+    db: db_migrations
+  lease_ttl_seconds: 300
+  acquire_behavior: wait
+  default_wait_timeout_seconds: 300
+  acquire_backoff:
+    initial_ms: 200
+    max_ms: 5000
+    multiplier: 2
+    jitter_ms: 150
+protected_areas:
+  - agentic/orchestrator/schemas
+  - agentic/orchestrator/policy.yaml
+required_modes:
+  - fast
+  - full
+required_merge_mode: merge
+collision_policy: reject
+config_precedence:
+  policy_hard_constraints:
+    - execution.default_step_timeout_seconds
+    - testing.coverage.minimums
+    - testing.coverage.targets
+  gates_profile_defaults:
+    - profiles
+  plan_verification_overrides:
+    - verification_overrides
+path_rules:
+  matching: repo_prefix
+  normalize_paths: true
+  allow_symlink_traversal: false
+execution:
+  default_step_timeout_seconds: 600
+  retry_policy:
+    transient_max_retries: 1
+    transient_error_codes:
+      - 124
+    non_retryable_error_codes:
+      - 2
+      - 126
+      - 127
+  env_allowlist:
+    - PATH
+    - HOME
+implementation:
+  workspace: nx
+testing:
+  framework: vitest
+  coverage:
+    minimums:
+      line: 0.7
+      branch: 0.7
+    targets:
+      line: 1.0
+      branch: 1.0
+merge_policy:
+  require_user_approval: true
+  allowed_strategies:
+    - merge_commit
+    - squash
+    - rebase
+worktree:
+  base_branch: ${context.defaultBranch}
+rbac:
+  orchestrator:
+    - feature.discover_specs
+    - feature.init
+    - feature.get_context
+    - feature.state_get
+    - feature.state_patch
+    - feature.log_append
+    - plan.submit
+    - plan.get
+    - plan.update
+    - repo.ensure_worktree
+    - repo.apply_patch
+    - repo.status
+    - repo.diff
+    - repo.read_file
+    - repo.search
+    - gates.list
+    - gates.run
+    - evidence.latest
+    - locks.acquire
+    - locks.release
+    - collisions.scan
+    - report.dashboard
+    - report.feature_summary
+    - feature.ready_to_merge
+    - feature.delete
+  planner:
+    - feature.get_context
+    - feature.state_get
+    - plan.submit
+    - plan.update
+    - collisions.scan
+    - repo.read_file
+    - repo.search
+  builder:
+    - feature.get_context
+    - feature.state_get
+    - repo.apply_patch
+    - repo.status
+    - repo.diff
+    - repo.read_file
+    - repo.search
+    - gates.run
+  qa:
+    - feature.get_context
+    - feature.state_get
+    - repo.apply_patch
+    - repo.diff
+    - repo.read_file
+    - repo.search
+    - gates.run
+    - evidence.latest
+  system:
+    - "*"
+recovery:
+  orchestrator_session_reattach_timeout_ms: 5000
+  orphan_session_cleanup_enabled: true
+supervisor:
+  max_iterations_per_phase: 6
+  max_parallel_gate_runs: ${wizard.maxParallelGateRuns}
+cleanup:
+  auto_after_merge: false
+  grace_period_seconds: 3600
+dashboard:
+  enabled: true
+  port: ${wizard.dashboardPort}
+notifications:
+  enabled: ${notificationsEnabled}
+  channels:
+    desktop:
+      enabled: ${wizard.notifications.desktop}
+    slack:
+      enabled: ${wizard.notifications.slack}
+      webhook: "${escapeYamlString(wizard.notifications.slackWebhook)}"
+      channel: "#aop-alerts"
+    webhook:
+      enabled: ${wizard.notifications.webhook}
+      url: "${escapeYamlString(wizard.notifications.webhookUrl)}"
+`;
+}
+
+function generateGatesYaml(framework: TestFramework): string {
+  const cmds = buildGateCommands(framework);
+  return `version: 1
+profiles:
+  default:
+    modes:
+      fast:
+        - name: test
+          cmd: [${yamlList(cmds.test)}]
+          timeout_seconds: 600
+      full:
+        - name: test_with_coverage
+          cmd: [${yamlList(cmds.testWithCoverage)}]
+          timeout_seconds: 1200
+      merge:
+        - name: merge_safety
+          cmd: [${yamlList(cmds.testWithCoverage)}]
+          timeout_seconds: 1200
+    parsers:
+      coverage:
+        type: lcov
+        path: coverage/lcov.info
+    thresholds:
+      coverage_line_min: 0.7
+      coverage_branch_min: 0.7
+      coverage_line_target: 1.0
+      coverage_branch_target: 1.0
+capabilities:
+  - none
+  - lcov
+`;
+}
+
+function generateAgentsYaml(): string {
+  return `version: 1
+roles:
+  planner:
+    system_prompt_path: agentic/orchestrator/prompts/planner.system.md
+  builder:
+    system_prompt_path: agentic/orchestrator/prompts/builder.system.md
+  qa:
+    system_prompt_path: agentic/orchestrator/prompts/qa.system.md
+missing_prompt_behavior: ignore
+runtime:
+  default_provider: custom
+  default_model: local-default
+  provider_config_env: AOP_PROVIDER_CONFIG_ENV
+  role_provider_overrides: {}
+`;
+}
+
+function generateAdaptersYaml(): string {
+  return `notification-channel: desktop
+activity-detector: claude-jsonl
+scm-provider: github
+`;
+}
+
+function parseInteger(raw: string, fallback: number, min: number, max: number): number {
+  const parsed = Number.parseInt(raw, 10);
+  if (Number.isNaN(parsed)) {
+    return fallback;
+  }
+  if (parsed < min || parsed > max) {
+    return fallback;
+  }
+  return parsed;
+}
+
+function parseFramework(raw: string, fallback: TestFramework): TestFramework {
+  const value = raw.trim().toLowerCase();
+  if (value === 'vitest' || value === 'jest' || value === 'pytest' || value === 'maven' || value === 'gradle') {
+    return value;
+  }
+  return fallback;
+}
+
+function parseNotificationChannels(raw: string): { desktop: boolean; slack: boolean; webhook: boolean } {
+  const normalized = raw.trim().toLowerCase();
+  if (!normalized || normalized === 'none') {
+    return { desktop: false, slack: false, webhook: false };
+  }
+  const channels = new Set(normalized.split(',').map((token) => token.trim()).filter((token) => token.length > 0));
+  return {
+    desktop: channels.has('desktop'),
+    slack: channels.has('slack'),
+    webhook: channels.has('webhook')
+  };
+}
+
+async function askWithDefault(prompt: PromptSession, label: string, defaultValue: string): Promise<string> {
+  const raw = (await prompt.question(`${label} [${defaultValue}]: `)).trim();
+  return raw.length > 0 ? raw : defaultValue;
+}
+
+async function collectWizardConfig(
+  defaults: { branch: string; framework: TestFramework },
+  promptFactory: () => PromptSession
+): Promise<WizardConfig> {
+  const prompt = promptFactory();
+  try {
+    const baseBranch = await askWithDefault(prompt, 'Worktree base branch', defaults.branch);
+    const maxParallelGateRunsRaw = await askWithDefault(prompt, 'Max parallel gate runs', '3');
+    const dashboardPortRaw = await askWithDefault(prompt, 'Dashboard port', '3000');
+    const channelsRaw = await askWithDefault(
+      prompt,
+      'Notification channels (comma-separated: desktop,slack,webhook,none)',
+      'none'
+    );
+    const frameworkRaw = await askWithDefault(
+      prompt,
+      'Test framework (vitest|jest|pytest|maven|gradle)',
+      defaults.framework
+    );
+
+    const channels = parseNotificationChannels(channelsRaw);
+    let slackWebhook = '';
+    let webhookUrl = '';
+
+    if (channels.slack) {
+      slackWebhook = (await prompt.question('Slack webhook URL []: ')).trim();
+    }
+    if (channels.webhook) {
+      webhookUrl = (await prompt.question('Webhook URL []: ')).trim();
+    }
+
+    return {
+      baseBranch,
+      maxParallelGateRuns: parseInteger(maxParallelGateRunsRaw, 3, 1, 64),
+      dashboardPort: parseInteger(dashboardPortRaw, 3000, 1, 65535),
+      framework: parseFramework(frameworkRaw, defaults.framework),
+      notifications: {
+        desktop: channels.desktop,
+        slack: channels.slack,
+        webhook: channels.webhook,
+        slackWebhook,
+        webhookUrl
+      }
+    };
+  } finally {
+    prompt.close();
+  }
+}
+
+async function loadTemplateFiles(
+  subdir: 'prompts' | 'schemas',
+  matcher: (filename: string) => boolean
+): Promise<Array<{ rel: string; content: string }>> {
+  const sourceDir = path.join(TEMPLATE_ROOT, subdir);
+  const entries = await fs.readdir(sourceDir, { withFileTypes: true });
+  const templates: Array<{ rel: string; content: string }> = [];
+  for (const entry of entries) {
+    if (!entry.isFile() || !matcher(entry.name)) {
+      continue;
+    }
+    const full = path.join(sourceDir, entry.name);
+    templates.push({
+      rel: `agentic/orchestrator/${subdir}/${entry.name}`,
+      content: await fs.readFile(full, 'utf8')
+    });
+  }
+  return templates.sort((a, b) => a.rel.localeCompare(b.rel));
+}
+
+export class InitCommandHandler {
+  private readonly repoRoot: string;
+  private readonly promptFactory: () => PromptSession;
+
+  constructor(repoRoot: string, promptFactory: () => PromptSession = createPromptSession) {
+    this.repoRoot = repoRoot;
+    this.promptFactory = promptFactory;
+  }
+
+  async execute(options: InitOptions): Promise<InitCommandResult> {
+    const gitContext = await detectGitContext(this.repoRoot);
+    const framework = await detectTestFramework(this.repoRoot);
+    const wizard = options.auto
+      ? {
+          baseBranch: gitContext.defaultBranch,
+          maxParallelGateRuns: 3,
+          dashboardPort: 3000,
+          framework,
+          notifications: {
+            desktop: false,
+            slack: false,
+            webhook: false,
+            slackWebhook: '',
+            webhookUrl: ''
+          }
+        }
+      : await collectWizardConfig(
+          {
+            branch: gitContext.defaultBranch,
+            framework
+          },
+          this.promptFactory
+        );
+
+    const orchestratorDir = path.join(this.repoRoot, 'agentic', 'orchestrator');
+    await fs.mkdir(orchestratorDir, { recursive: true });
+
+    const configFiles: Array<{ rel: string; content: string }> = [
+      {
+        rel: 'agentic/orchestrator/policy.yaml',
+        content: generatePolicyYaml({ ...gitContext, defaultBranch: wizard.baseBranch }, wizard)
+      },
+      { rel: 'agentic/orchestrator/gates.yaml', content: generateGatesYaml(wizard.framework) },
+      { rel: 'agentic/orchestrator/agents.yaml', content: generateAgentsYaml() },
+      { rel: 'agentic/orchestrator/adapters.yaml', content: generateAdaptersYaml() }
+    ];
+    const templateFiles = [
+      ...(await loadTemplateFiles('prompts', (filename) => filename.endsWith('.md'))),
+      ...(await loadTemplateFiles('schemas', (filename) => filename.endsWith('.json')))
+    ];
+    const writableFiles = [...configFiles, ...templateFiles];
+
+    const created: string[] = [];
+    const updated: string[] = [];
+    const skipped: string[] = [];
+
+    for (const { rel, content } of writableFiles) {
+      const filePath = path.join(this.repoRoot, rel);
+      await fs.mkdir(path.dirname(filePath), { recursive: true });
+      let exists = false;
+      try {
+        await fs.access(filePath);
+        exists = true;
+      } catch {
+        // file does not exist
+      }
+
+      if (exists && !options.force) {
+        skipped.push(rel);
+        continue;
+      }
+
+      await fs.writeFile(filePath, content, 'utf8');
+      if (exists) {
+        updated.push(rel);
+      } else {
+        created.push(rel);
+      }
+    }
+
+    const validationWarnings: string[] = [];
+    const schemaRegistry = new SchemaRegistry(this.repoRoot);
+    const validationTargets: Array<{ schema: string; rel: string }> = [
+      { schema: 'policy.schema.json', rel: 'agentic/orchestrator/policy.yaml' },
+      { schema: 'gates.schema.json', rel: 'agentic/orchestrator/gates.yaml' },
+      { schema: 'agents.schema.json', rel: 'agentic/orchestrator/agents.yaml' },
+      { schema: 'adapters.schema.json', rel: 'agentic/orchestrator/adapters.yaml' }
+    ];
+
+    for (const { schema, rel } of validationTargets) {
+      if (skipped.includes(rel)) {
+        continue;
+      }
+      try {
+        const raw = await fs.readFile(path.join(this.repoRoot, rel), 'utf8');
+        const parsed: unknown = YAML.parse(raw);
+        const result = await schemaRegistry.validate(schema, parsed);
+        if (!result.valid) {
+          const messages = result.errors.map((e) => e.message ?? String(e)).join('; ');
+          validationWarnings.push(`${rel}: ${messages}`);
+        }
+      } catch (err) {
+        validationWarnings.push(`Failed to validate ${rel}: ${String(err)}`);
+      }
+    }
+
+    return {
+      ok: true,
+      data: {
+        command: 'init',
+        created,
+        updated,
+        skipped,
+        validation_warnings: validationWarnings,
+        next_steps: [
+          'Review generated files in agentic/orchestrator/{policy,gates,agents,adapters}.yaml',
+          'Verify prompts under agentic/orchestrator/prompts/ and schemas under agentic/orchestrator/schemas/',
+          'Run: aop run -fi <spec.md> to start orchestrating features'
+        ]
+      }
+    };
+  }
+}

package/apps/control-plane/src/cli/resume-command-handler.ts

@@ -189,6 +189,7 @@ export class ResumeCommandHandler {
           sources: [...(sourcesByFeature.get(featureId) ?? new Set<string>())].sort((a, b) => a.localeCompare(b))
         });
       } catch (_error) {
+        // Silently skip features with parse errors
       }
     }