@besales/ops-framework 0.1.0

package/bin/lib/llm-input-pack-utils.test.mjs

@@ -0,0 +1,262 @@
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { afterEach, describe, expect, it } from 'vitest';
+import {
+  buildCheckerLlmInputPack,
+  buildContextModeSequence,
+  buildVerifierLlmInputPack,
+  estimatePayload,
+  isContextInsufficientResult,
+  resolveLlmContextMode,
+} from './llm-input-pack-utils.mjs';
+
+const tempDirs = [];
+
+afterEach(() => {
+  for (const dir of tempDirs.splice(0)) {
+    fs.rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+describe('llm input pack utilities', () => {
+  it('estimates compact payload size and reports compacted artifacts', () => {
+    const taskDir = createTask();
+    const pack = buildCheckerLlmInputPack({
+      taskDir,
+      taskId: 'TASK-999-token-pack',
+      checkerPromptSha: 'sha256:test',
+      cacheKey: { test: true },
+      checkContext: {
+        planSha: 'sha256:plan',
+        memorySha: 'sha256:memory',
+        riskProfile: 'medium',
+        riskTriggers: ['panel-ui'],
+      },
+      checkEvidence: '# Evidence\n\nok',
+      checkerContextPack: '# Checker Context Pack\n\nok',
+      taskManifest: '{}',
+      projectMemory: [{ path: 'memory.md', sha: 'sha256:m', content: 'memory' }],
+      mode: 'fast',
+    });
+
+    expect(pack.meta.estimatedTokens).toBeGreaterThan(0);
+    expect(pack.meta.compactedArtifacts).toContain('plan.md');
+    expect(estimatePayload(pack.input).estimatedTokens).toBe(pack.meta.estimatedTokens);
+  });
+
+  it('does not include full orchestration log in fast or standard verifier packs', () => {
+    const taskDir = createTask({ orchestrationEvents: 100 });
+    const fullLog = fs.readFileSync(path.join(taskDir, 'orchestration-log.md'), 'utf8');
+    const pack = buildVerifierLlmInputPack({
+      taskDir,
+      taskId: 'TASK-999-token-pack',
+      planSha: 'sha256:plan',
+      executionSha: 'sha256:execution',
+      verifier: { provider: 'test', model: 'test', reasoningEffort: 'none', runId: 'run' },
+      mode: 'standard',
+    });
+
+    expect(pack.input.taskArtifacts['orchestration-log.md']).toContain('# Orchestration Log Compact');
+    expect(pack.input.taskArtifacts['orchestration-log.md'].length).toBeLessThan(fullLog.length);
+    expect(pack.meta.compactedArtifacts).toContain('orchestration-log.md');
+  });
+
+  it('keeps full artifacts in strict verifier pack', () => {
+    const taskDir = createTask({ orchestrationEvents: 8 });
+    const fullLog = fs.readFileSync(path.join(taskDir, 'orchestration-log.md'), 'utf8');
+    const pack = buildVerifierLlmInputPack({
+      taskDir,
+      taskId: 'TASK-999-token-pack',
+      planSha: 'sha256:plan',
+      executionSha: 'sha256:execution',
+      verifier: { provider: 'test', model: 'test', reasoningEffort: 'none', runId: 'run' },
+      mode: 'strict',
+    });
+
+    expect(pack.input.taskArtifacts['orchestration-log.md']).toBe(fullLog);
+    expect(pack.meta.compactedArtifacts).not.toContain('orchestration-log.md');
+  });
+
+  it('builds bounded fallback mode sequence for context insufficient results', () => {
+    expect(buildContextModeSequence('fast')).toEqual(['fast', 'standard', 'strict']);
+    expect(buildContextModeSequence('standard')).toEqual(['standard', 'strict']);
+    expect(buildContextModeSequence('strict')).toEqual(['strict']);
+    expect(isContextInsufficientResult({ verdict: 'context_insufficient' })).toBe(true);
+  });
+
+  it('preserves protected verification sections when compacting long plans', () => {
+    const taskDir = createTask();
+    const longPlan = [
+      '# Plan',
+      '',
+      '## Цель',
+      '',
+      'A'.repeat(6000),
+      '',
+      '## Verification Plan',
+      '',
+      'Must run UI acceptance and performance checks.',
+      '',
+      '## Что требует human approval',
+      '',
+      'B'.repeat(6000),
+    ].join('\n');
+    write(taskDir, 'plan.md', longPlan);
+
+    const pack = buildCheckerLlmInputPack({
+      taskDir,
+      taskId: 'TASK-999-token-pack',
+      checkerPromptSha: 'sha256:test',
+      cacheKey: { test: true },
+      checkContext: {
+        planSha: 'sha256:plan',
+        memorySha: 'sha256:memory',
+        riskProfile: 'medium',
+        riskTriggers: ['panel-ui'],
+      },
+      checkEvidence: '# Evidence\n\nok',
+      checkerContextPack: '# Checker Context Pack\n\nok',
+      taskManifest: '{}',
+      projectMemory: [],
+      mode: 'fast',
+    });
+
+    expect(pack.input.taskArtifacts['plan.md']).toContain('## Verification Plan');
+    expect(pack.input.taskArtifacts['plan.md']).toContain('Must run UI acceptance and performance checks.');
+    expect(pack.input.taskArtifacts['plan.md'].length).toBeLessThan(5000);
+  });
+
+  it('marks dropped protected sections when a compact pack cannot keep all of them', () => {
+    const taskDir = createTask();
+    write(taskDir, 'execution.md', [
+      '# Execution',
+      '',
+      '## UI Acceptance Evidence',
+      '',
+      'A'.repeat(2200),
+      '',
+      '## Complexity / Performance Evidence',
+      '',
+      'B'.repeat(2200),
+      '',
+      '## Production Rollout Evidence',
+      '',
+      'C'.repeat(2200),
+    ].join('\n'));
+
+    const pack = buildVerifierLlmInputPack({
+      taskDir,
+      taskId: 'TASK-999-token-pack',
+      planSha: 'sha256:plan',
+      executionSha: 'sha256:execution',
+      verifier: { provider: 'test', model: 'test', reasoningEffort: 'none', runId: 'run' },
+      mode: 'fast',
+    });
+
+    expect(pack.input.taskArtifacts['execution.md']).toContain('<!-- dropped-protected:');
+  });
+
+  it('includes non-blocking findings and questions in compact check markdown', () => {
+    const taskDir = createTask();
+    write(taskDir, 'check.result.json', JSON.stringify({
+      verdict: 'ready_for_human_gate',
+      findings: [
+        {
+          id: 'F-001',
+          severity: 'non_blocking',
+          claimCategory: 'missing_verification',
+          claim: 'Non-blocking concern should remain visible.',
+          expectedCorrection: 'Track in verifier.',
+        },
+        {
+          id: 'F-002',
+          severity: 'question',
+          claimCategory: 'human_decision_required',
+          claim: 'Human question should remain visible.',
+          expectedCorrection: 'Ask human.',
+        },
+      ],
+    }, null, 2));
+
+    const pack = buildVerifierLlmInputPack({
+      taskDir,
+      taskId: 'TASK-999-token-pack',
+      planSha: 'sha256:plan',
+      executionSha: 'sha256:execution',
+      verifier: { provider: 'test', model: 'test', reasoningEffort: 'none', runId: 'run' },
+      mode: 'standard',
+    });
+
+    expect(pack.input.taskArtifacts['check.md']).toContain('Non-blocking concern should remain visible.');
+    expect(pack.input.taskArtifacts['check.md']).toContain('Human question should remain visible.');
+  });
+
+  it('uses a conservative estimate for Cyrillic and JSON-heavy payloads', () => {
+    const value = JSON.stringify({
+      text: 'Проверка русскоязычного JSON payload с большим количеством кавычек и структурных символов.',
+      rows: Array.from({ length: 20 }, (_, index) => ({ index, value: 'значение' })),
+    });
+    const pack = estimatePayload(value);
+
+    expect(pack.estimatedTokens).toBeGreaterThan(Math.ceil(value.length / 2.3));
+  });
+
+  it('defaults high-risk production/source-sync tasks to strict context', () => {
+    expect(resolveLlmContextMode({ riskTriggers: ['production-runtime'] })).toBe('strict');
+    expect(resolveLlmContextMode({ riskTriggers: ['source-sync-provider'] })).toBe('strict');
+    expect(resolveLlmContextMode({ riskTriggers: ['panel-ui'] })).toBe('standard');
+    expect(resolveLlmContextMode({ requestedMode: 'fast', riskTriggers: ['production-runtime'] })).toBe('fast');
+  });
+});
+
+function createTask({ orchestrationEvents = 40 } = {}) {
+  const taskDir = fs.mkdtempSync(path.join(os.tmpdir(), 'TASK-999-token-pack-'));
+  tempDirs.push(taskDir);
+  write(taskDir, 'brief.md', '# Brief\n\nShort brief.');
+  write(taskDir, 'research.md', '# Research\n\n## Findings\n\n- `web/app/src/example.tsx` is relevant.');
+  write(taskDir, 'plan.md', [
+    '# Plan',
+    '',
+    '## Затронутые модули и файлы',
+    '',
+    '- `web/app/src/example.tsx`',
+    '',
+    '## UI Acceptance Scenarios',
+    '',
+    '| ID | User intent | Setup/data | Steps | Expected visible result | Must catch |',
+    '| --- | --- | --- | --- | --- | --- |',
+    '| UI-001 | inspect page | seeded data | open page | visible rows | stale rows |',
+  ].join('\n'));
+  write(taskDir, 'execution.md', [
+    '# Execution',
+    '',
+    '## Измененные файлы',
+    '',
+    '| File | Change summary | Planned item / reason |',
+    '| --- | --- | --- |',
+    '| `web/app/src/example.tsx` | update | plan |',
+    '',
+    '## UI Acceptance Evidence',
+    '',
+    '| Scenario ID | Result | Observed evidence / screenshot / payload | Notes |',
+    '| --- | --- | --- | --- |',
+    '| UI-001 | pass | observed visible rows screenshot `/tmp/ui.png` | ok |',
+  ].join('\n'));
+  write(taskDir, 'status.md', '# Status\n\n## Текущий этап\n\nverify\n\n## Следующий шаг\n\nRun verify.');
+  write(taskDir, 'check.result.json', JSON.stringify({ verdict: 'ready_for_human_gate', findings: [] }, null, 2));
+  write(taskDir, 'check.md', '# Check\n\n## Итоговая оценка\n\nReady.');
+  write(taskDir, 'execution-ledger.json', JSON.stringify({ git: { changedFiles: [] } }, null, 2));
+  write(taskDir, 'task-manifest.json', JSON.stringify({ context: { riskTriggers: ['panel-ui'] } }, null, 2));
+  write(taskDir, 'orchestration-log.md', [
+    '# Orchestration Log',
+    '',
+    '## Entries',
+    ...Array.from({ length: orchestrationEvents }, (_, index) => `- \`2026-05-21T00:${String(index).padStart(2, '0')}:00.000Z\` - event ${index} return_to_plan detail ${'x'.repeat(80)}`),
+  ].join('\n'));
+  return taskDir;
+}
+
+function write(taskDir, fileName, content) {
+  fs.writeFileSync(path.join(taskDir, fileName), `${content}\n`);
+}

package/bin/lib/project-config.mjs

@@ -0,0 +1,229 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+export const frameworkRoot = path.resolve(__dirname, '..', '..');
+export const projectConfigFileName = path.join('ops', 'project.ops.yaml');
+
+export function resolveProjectContext({ cwd = process.cwd() } = {}) {
+  const configPath = findProjectConfig(cwd);
+  if (configPath) {
+    const projectRoot = path.dirname(path.dirname(configPath));
+    const config = parseProjectOpsConfig(fs.readFileSync(configPath, 'utf8'));
+    return buildConfiguredContext({ projectRoot, configPath, config });
+  }
+  return buildLegacyContext({ cwd });
+}
+
+export function findProjectConfig(startDir) {
+  let current = path.resolve(startDir);
+  while (true) {
+    const candidate = findProjectConfigInDirectory(current);
+    if (fs.existsSync(candidate)) {
+      return candidate;
+    }
+    const parent = path.dirname(current);
+    if (parent === current) {
+      return null;
+    }
+    current = parent;
+  }
+}
+
+function findProjectConfigInDirectory(directory) {
+  const defaultCandidate = path.join(directory, projectConfigFileName);
+  if (fs.existsSync(defaultCandidate)) {
+    return defaultCandidate;
+  }
+  let entries = [];
+  try {
+    entries = fs.readdirSync(directory, { withFileTypes: true });
+  } catch {
+    return defaultCandidate;
+  }
+  const candidates = entries
+    .filter((entry) => entry.isDirectory())
+    .map((entry) => path.join(directory, entry.name, 'project.ops.yaml'))
+    .filter((candidate) => fs.existsSync(candidate))
+    .sort();
+  return candidates[0] || defaultCandidate;
+}
+
+export function parseProjectOpsConfig(content) {
+  const config = {};
+  const stack = [{ indent: -1, value: config, parent: null, key: null }];
+  for (const rawLine of content.split(/\r?\n/)) {
+    const withoutComment = rawLine.replace(/\s+#.*$/, '');
+    if (!withoutComment.trim()) {
+      continue;
+    }
+    const listMatch = /^(\s*)-\s+(.*)$/.exec(withoutComment);
+    if (listMatch) {
+      const indent = listMatch[1].length;
+      while (stack.length > 1 && indent < stack[stack.length - 1].indent) {
+        stack.pop();
+      }
+      const frame = stack[stack.length - 1];
+      if (!Array.isArray(frame.value)) {
+        if (!frame.parent || frame.key === null || Object.keys(frame.value || {}).length > 0) {
+          throw new Error(`Unsupported project.ops.yaml list item: ${rawLine}`);
+        }
+        frame.parent[frame.key] = [];
+        frame.value = frame.parent[frame.key];
+      }
+      frame.value.push(parseScalar(listMatch[2].trim()));
+      continue;
+    }
+    const match = /^(\s*)([A-Za-z0-9_-]+):(?:\s+(.*))?$/.exec(withoutComment);
+    if (!match) {
+      throw new Error(`Unsupported project.ops.yaml line: ${rawLine}`);
+    }
+    const indent = match[1].length;
+    const key = match[2];
+    const rawValue = match[3];
+    while (stack.length > 1 && indent <= stack[stack.length - 1].indent) {
+      stack.pop();
+    }
+    const parent = stack[stack.length - 1].value;
+    if (rawValue === undefined || rawValue === '') {
+      parent[key] = {};
+      stack.push({
+        indent,
+        value: parent[key],
+        parent,
+        key,
+      });
+    } else {
+      parent[key] = parseScalar(rawValue.trim());
+    }
+  }
+  return config;
+}
+
+export function readJsonIfExists(filePath) {
+  if (!filePath || !fs.existsSync(filePath)) {
+    return {};
+  }
+  return JSON.parse(fs.readFileSync(filePath, 'utf8'));
+}
+
+export function deepMerge(base, override) {
+  if (!isPlainObject(base) || !isPlainObject(override)) {
+    return override === undefined ? base : override;
+  }
+  const merged = { ...base };
+  for (const [key, value] of Object.entries(override)) {
+    merged[key] = key in merged ? deepMerge(merged[key], value) : value;
+  }
+  return merged;
+}
+
+function buildConfiguredContext({ projectRoot, configPath, config }) {
+  const ops = config.ops || {};
+  const agents = config.agents || {};
+  const risk = config.risk || {};
+  const legacyPipelineRoot = resolveProjectPath(projectRoot, ops.legacyPipelineDir || 'ops/agent-pipeline');
+  return {
+    configPath,
+    config,
+    projectRoot,
+    repoRoot: projectRoot,
+    frameworkRoot,
+    pipelineRoot: legacyPipelineRoot,
+    tasksRoot: resolveProjectPath(projectRoot, ops.tasksDir || 'ops/agent-pipeline/tasks'),
+    memoryRoot: resolveProjectPath(projectRoot, ops.memoryDir || 'ops/agent-pipeline/memory'),
+    cacheRoot: resolveProjectPath(projectRoot, ops.cacheDir || 'ops/agent-pipeline/cache'),
+    promptsRoot: path.join(frameworkRoot, 'prompts'),
+    templatesRoot: path.join(frameworkRoot, 'templates'),
+    playbooksRoot: path.join(frameworkRoot, 'playbooks'),
+    sharedPlaybooksRoot: path.join(frameworkRoot, 'playbooks'),
+    projectPlaybooksRoot: ops.playbooksDir ? resolveProjectPath(projectRoot, ops.playbooksDir) : null,
+    configRoot: path.join(frameworkRoot, 'config'),
+    projectAgentsConfigPath: agents.configFile ? resolveProjectPath(projectRoot, agents.configFile) : null,
+    risk: {
+      uiRoots: normalizeStringList(risk.uiRoots),
+      backendRoots: normalizeStringList(risk.backendRoots),
+      workerRoots: normalizeStringList(risk.workerRoots),
+    },
+  };
+}
+
+function buildLegacyContext({ cwd }) {
+  const resolvedCwd = path.resolve(cwd);
+  const legacyPipelineRoot = findLegacyPipelineRoot(resolvedCwd) || frameworkRoot;
+  const projectRoot = path.resolve(legacyPipelineRoot, '..', '..');
+  return {
+    configPath: null,
+    config: {},
+    projectRoot,
+    repoRoot: projectRoot,
+    frameworkRoot,
+    pipelineRoot: legacyPipelineRoot,
+    tasksRoot: path.join(legacyPipelineRoot, 'tasks'),
+    memoryRoot: path.join(legacyPipelineRoot, 'memory'),
+    cacheRoot: path.join(legacyPipelineRoot, 'cache'),
+    promptsRoot: path.join(frameworkRoot, 'prompts'),
+    templatesRoot: path.join(frameworkRoot, 'templates'),
+    playbooksRoot: path.join(frameworkRoot, 'playbooks'),
+    sharedPlaybooksRoot: path.join(frameworkRoot, 'playbooks'),
+    projectPlaybooksRoot: path.join(legacyPipelineRoot, 'playbooks'),
+    configRoot: path.join(frameworkRoot, 'config'),
+    projectAgentsConfigPath: path.join(legacyPipelineRoot, 'config', 'agents.json'),
+    risk: {
+      uiRoots: [],
+      backendRoots: [],
+      workerRoots: [],
+    },
+  };
+}
+
+function findLegacyPipelineRoot(startDir) {
+  let current = path.resolve(startDir);
+  while (true) {
+    const candidate = path.join(current, 'ops', 'agent-pipeline');
+    if (fs.existsSync(candidate)) {
+      return candidate;
+    }
+    const parent = path.dirname(current);
+    if (parent === current) {
+      return null;
+    }
+    current = parent;
+  }
+}
+
+function resolveProjectPath(projectRoot, maybeRelative) {
+  return path.isAbsolute(maybeRelative)
+    ? maybeRelative
+    : path.resolve(projectRoot, maybeRelative);
+}
+
+function parseScalar(value) {
+  if ((value.startsWith('"') && value.endsWith('"')) || (value.startsWith("'") && value.endsWith("'"))) {
+    return value.slice(1, -1);
+  }
+  if (value === 'true') {
+    return true;
+  }
+  if (value === 'false') {
+    return false;
+  }
+  return value;
+}
+
+function isPlainObject(value) {
+  return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
+
+function normalizeStringList(value) {
+  if (Array.isArray(value)) {
+    return value.map(String).filter(Boolean);
+  }
+  if (typeof value === 'string' && value.trim()) {
+    return value.split(',').map((item) => item.trim()).filter(Boolean);
+  }
+  return [];
+}

package/bin/lib/project-config.test.mjs

@@ -0,0 +1,102 @@
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { describe, expect, it } from 'vitest';
+import {
+  deepMerge,
+  findProjectConfig,
+  parseProjectOpsConfig,
+  resolveProjectContext,
+} from './project-config.mjs';
+
+describe('project config resolver', () => {
+  it('parses the supported project.ops.yaml shape', () => {
+    const config = parseProjectOpsConfig(`
+name: ExampleProject
+ops:
+  tasksDir: ops/agent-pipeline/tasks
+  memoryDir: ops/agent-pipeline/memory
+agents:
+  configFile: ops/agent-pipeline/config/agents.json
+risk:
+  uiRoots:
+    - web/app
+  backendRoots:
+    - services/api
+`);
+
+    expect(config.name).toBe('ExampleProject');
+    expect(config.ops.tasksDir).toBe('ops/agent-pipeline/tasks');
+    expect(config.ops.memoryDir).toBe('ops/agent-pipeline/memory');
+    expect(config.agents.configFile).toBe('ops/agent-pipeline/config/agents.json');
+    expect(config.risk.uiRoots).toEqual(['web/app']);
+    expect(config.risk.backendRoots).toEqual(['services/api']);
+  });
+
+  it('finds project config by walking upward from cwd', () => {
+    const root = fs.mkdtempSync(path.join(os.tmpdir(), 'ops-project-'));
+    const nested = path.join(root, 'apps', 'tool');
+    fs.mkdirSync(path.join(root, 'ops'), { recursive: true });
+    fs.mkdirSync(nested, { recursive: true });
+    fs.writeFileSync(path.join(root, 'ops', 'project.ops.yaml'), 'name: Fixture\n');
+
+    expect(findProjectConfig(nested)).toBe(path.join(root, 'ops', 'project.ops.yaml'));
+  });
+
+  it('finds project config in a custom ops root by walking upward from cwd', () => {
+    const root = fs.mkdtempSync(path.join(os.tmpdir(), 'ops-project-'));
+    const nested = path.join(root, 'apps', 'tool');
+    fs.mkdirSync(path.join(root, '.ops'), { recursive: true });
+    fs.mkdirSync(nested, { recursive: true });
+    fs.writeFileSync(path.join(root, '.ops', 'project.ops.yaml'), 'name: Fixture\n');
+
+    expect(findProjectConfig(nested)).toBe(path.join(root, '.ops', 'project.ops.yaml'));
+  });
+
+  it('resolves project-owned paths separately from framework assets', () => {
+    const root = fs.mkdtempSync(path.join(os.tmpdir(), 'ops-project-'));
+    const nested = path.join(root, 'workspace');
+    fs.mkdirSync(path.join(root, 'ops'), { recursive: true });
+    fs.mkdirSync(nested, { recursive: true });
+    fs.writeFileSync(path.join(root, 'ops', 'project.ops.yaml'), `
+name: Fixture
+ops:
+  legacyPipelineDir: ops/agent-pipeline
+  tasksDir: ops/agent-pipeline/tasks
+  memoryDir: ops/agent-pipeline/memory
+  cacheDir: ops/agent-pipeline/cache
+  playbooksDir: ops/agent-pipeline/playbooks
+agents:
+  configFile: ops/agent-pipeline/config/agents.json
+risk:
+  uiRoots:
+    - web/app
+  backendRoots:
+    - services/api
+  workerRoots:
+    - workers/backend
+`);
+
+    const context = resolveProjectContext({ cwd: nested });
+
+    expect(context.repoRoot).toBe(root);
+    expect(context.tasksRoot).toBe(path.join(root, 'ops', 'agent-pipeline', 'tasks'));
+    expect(context.memoryRoot).toBe(path.join(root, 'ops', 'agent-pipeline', 'memory'));
+    expect(context.cacheRoot).toBe(path.join(root, 'ops', 'agent-pipeline', 'cache'));
+    expect(context.promptsRoot).toBe(path.join(context.frameworkRoot, 'prompts'));
+    expect(context.projectPlaybooksRoot).toBe(path.join(root, 'ops', 'agent-pipeline', 'playbooks'));
+    expect(context.risk.uiRoots).toEqual(['web/app']);
+    expect(context.risk.backendRoots).toEqual(['services/api']);
+    expect(context.risk.workerRoots).toEqual(['workers/backend']);
+  });
+
+  it('deep merges shared defaults with project overrides', () => {
+    expect(deepMerge(
+      { checker: { provider: 'codex-cli', model: 'base' }, checkerProviders: { custom: { input: 'stdin' } } },
+      { checker: { model: 'project' }, checkerProviders: { custom: { output: 'stdout' } } },
+    )).toEqual({
+      checker: { provider: 'codex-cli', model: 'project' },
+      checkerProviders: { custom: { input: 'stdin', output: 'stdout' } },
+    });
+  });
+});