scene-capability-engine 3.6.10 → 3.6.13

package/lib/commands/task.js

@@ -12,6 +12,16 @@ const TaskClaimer = require('../task/task-claimer');
 const WorkspaceManager = require('../workspace/workspace-manager');
 const { TaskRefRegistry } = require('../task/task-ref-registry');
 const { ensureWriteAuthorization } = require('../security/write-authorization');
+const {
+  buildDraft,
+  scoreDraft,
+  appendDraft,
+  updateDraft,
+  consolidateDrafts,
+  loadDraftStore,
+  promoteDraftToTasks
+} = require('../task/task-quality');
+const { loadTaskQualityPolicy } = require('../task/task-quality-policy');
 
 function normalizeString(value) {
   if (typeof value !== 'string') {
@@ -32,6 +42,195 @@ function resolveStudioStageFromTaskKey(taskKey) {
   return normalizeString(normalized.slice('studio:'.length));
 }
 
+async function runTaskDraftCommand(options = {}) {
+  const projectPath = process.cwd();
+  const sceneId = normalizeString(options.scene);
+  const specId = normalizeString(options.spec);
+  const inputText = normalizeString(options.input);
+  const inputFile = normalizeString(options.inputFile);
+  const policyConfig = await loadTaskQualityPolicy(projectPath, options.policy, fs);
+  const policy = policyConfig.policy;
+
+  if (!sceneId) {
+    throw new Error('scene is required');
+  }
+
+  let rawRequest = inputText;
+  if (!rawRequest && inputFile) {
+    rawRequest = await fs.readFile(inputFile, 'utf8');
+  }
+  if (!rawRequest) {
+    throw new Error('input text is required (use --input or --input-file)');
+  }
+
+  const draft = buildDraft(rawRequest, {
+    scene_id: sceneId,
+    spec_id: specId,
+    acceptance_criteria: options.acceptance ? String(options.acceptance).split('|') : [],
+    confidence: options.confidence,
+    policy
+  });
+  const quality = scoreDraft(draft, policy);
+  draft.quality_score = quality.score;
+  draft.quality_breakdown = quality.breakdown;
+  draft.quality_issues = quality.issues;
+  draft.quality_passed = quality.passed;
+
+  const result = await appendDraft(projectPath, draft, fs);
+  const payload = {
+    mode: 'task-draft',
+    draft: draft,
+    store_path: result.store_path
+  };
+
+  if (options.json) {
+    process.stdout.write(`${JSON.stringify(payload, null, 2)}\n`);
+    return;
+  }
+
+  console.log(chalk.green('✅ Draft created'));
+  console.log(chalk.gray(`  id: ${draft.draft_id}`));
+  console.log(chalk.gray(`  score: ${draft.quality_score}`));
+}
+
+async function runTaskConsolidateCommand(options = {}) {
+  const projectPath = process.cwd();
+  const sceneId = normalizeString(options.scene);
+  const specId = normalizeString(options.spec);
+  if (!sceneId) {
+    throw new Error('scene is required');
+  }
+  const result = await consolidateDrafts(projectPath, {
+    scene_id: sceneId,
+    spec_id: specId
+  }, fs);
+
+  const payload = {
+    mode: 'task-consolidate',
+    scene_id: sceneId,
+    spec_id: specId || null,
+    merged: result.merged,
+    drafts: result.drafts,
+    store_path: result.store_path
+  };
+
+  if (options.json) {
+    process.stdout.write(`${JSON.stringify(payload, null, 2)}\n`);
+    return;
+  }
+
+  console.log(chalk.green('✅ Drafts consolidated'));
+  console.log(chalk.gray(`  merged: ${result.merged.length}`));
+}
+
+async function runTaskScoreCommand(options = {}) {
+  const projectPath = process.cwd();
+  const draftId = normalizeString(options.draft);
+  const all = Boolean(options.all);
+  const policyConfig = await loadTaskQualityPolicy(projectPath, options.policy, fs);
+  const policy = policyConfig.policy;
+  const store = await loadDraftStore(projectPath, fs);
+  const drafts = Array.isArray(store.payload.drafts) ? store.payload.drafts : [];
+
+  const targets = all
+    ? drafts
+    : drafts.filter((draft) => draft.draft_id === draftId);
+
+  if (!all && targets.length === 0) {
+    throw new Error(`draft not found: ${draftId}`);
+  }
+
+  const scored = [];
+  for (const draft of targets) {
+    const quality = scoreDraft(draft, policy);
+    const updated = await updateDraft(projectPath, draft.draft_id, (current) => ({
+      ...current,
+      quality_score: quality.score,
+      quality_breakdown: quality.breakdown,
+      quality_issues: quality.issues,
+      quality_passed: quality.passed
+    }), fs);
+    if (updated) {
+      scored.push(updated);
+    }
+  }
+
+  const payload = {
+    mode: 'task-score',
+    draft_id: draftId || null,
+    total: scored.length,
+    drafts: scored
+  };
+
+  if (options.json) {
+    process.stdout.write(`${JSON.stringify(payload, null, 2)}\n`);
+    return;
+  }
+
+  console.log(chalk.green('✅ Draft scoring complete'));
+  console.log(chalk.gray(`  scored: ${scored.length}`));
+}
+
+async function runTaskPromoteCommand(options = {}) {
+  const projectPath = process.cwd();
+  const draftId = normalizeString(options.draft);
+  const specId = normalizeString(options.spec);
+  const policyConfig = await loadTaskQualityPolicy(projectPath, options.policy, fs);
+  const policy = policyConfig.policy;
+  if (!draftId) {
+    throw new Error('draft id is required');
+  }
+  if (!specId) {
+    throw new Error('spec is required to promote draft');
+  }
+
+  const store = await loadDraftStore(projectPath, fs);
+  const drafts = Array.isArray(store.payload.drafts) ? store.payload.drafts : [];
+  const draft = drafts.find((item) => item.draft_id === draftId);
+  if (!draft) {
+    throw new Error(`draft not found: ${draftId}`);
+  }
+  const quality = scoreDraft(draft, policy);
+  if (!quality.passed && !options.force) {
+    throw new Error('draft quality gate failed; use --force to override');
+  }
+
+  const promoted = await promoteDraftToTasks(projectPath, {
+    ...draft,
+    spec_id: specId
+  }, fs);
+
+  const updated = await updateDraft(projectPath, draftId, (current) => ({
+    ...current,
+    spec_id: specId,
+    status: 'promoted',
+    quality_score: quality.score,
+    quality_breakdown: quality.breakdown,
+    quality_issues: quality.issues,
+    quality_passed: quality.passed,
+    promoted_at: new Date().toISOString(),
+    promoted_task_id: promoted.task_id,
+    promoted_tasks_path: promoted.tasks_path
+  }), fs);
+
+  const payload = {
+    mode: 'task-promote',
+    draft_id: draftId,
+    spec_id: specId,
+    task_id: promoted.task_id,
+    tasks_path: toRelativePosix(projectPath, promoted.tasks_path),
+    draft: updated
+  };
+
+  if (options.json) {
+    process.stdout.write(`${JSON.stringify(payload, null, 2)}\n`);
+    return;
+  }
+
+  console.log(chalk.green('✅ Draft promoted to tasks.md'));
+  console.log(chalk.gray(`  task: ${promoted.task_id}`));
+}
+
 function isStudioTaskRef(lookup = {}) {
   const source = normalizeString(lookup.source);
   if (source === 'studio-stage') {
@@ -771,6 +970,74 @@ function registerTaskCommands(program) {
         process.exitCode = 1;
       }
     });
+
+  task
+    .command('draft')
+    .description('Create a task draft from dialogue input')
+    .requiredOption('--scene <scene-id>', 'Scene identifier')
+    .option('--spec <spec-id>', 'Spec identifier')
+    .option('--input <text>', 'Raw task input text')
+    .option('--input-file <path>', 'File containing raw task input')
+    .option('--acceptance <items>', 'Pipe-delimited acceptance criteria')
+    .option('--confidence <score>', 'Manual confidence (0-1)')
+    .option('--policy <path>', 'Task quality policy path override')
+    .option('--json', 'Print machine-readable JSON output')
+    .action(async (options) => {
+      try {
+        await runTaskDraftCommand(options);
+      } catch (error) {
+        console.error(chalk.red(`Task draft failed: ${error.message}`));
+        process.exitCode = 1;
+      }
+    });
+
+  task
+    .command('consolidate')
+    .description('Consolidate task drafts by scene/spec')
+    .requiredOption('--scene <scene-id>', 'Scene identifier')
+    .option('--spec <spec-id>', 'Spec identifier')
+    .option('--json', 'Print machine-readable JSON output')
+    .action(async (options) => {
+      try {
+        await runTaskConsolidateCommand(options);
+      } catch (error) {
+        console.error(chalk.red(`Task consolidate failed: ${error.message}`));
+        process.exitCode = 1;
+      }
+    });
+
+  task
+    .command('score')
+    .description('Score task draft quality')
+    .option('--draft <draft-id>', 'Draft identifier')
+    .option('--all', 'Score all drafts')
+    .option('--policy <path>', 'Task quality policy path override')
+    .option('--json', 'Print machine-readable JSON output')
+    .action(async (options) => {
+      try {
+        await runTaskScoreCommand(options);
+      } catch (error) {
+        console.error(chalk.red(`Task score failed: ${error.message}`));
+        process.exitCode = 1;
+      }
+    });
+
+  task
+    .command('promote')
+    .description('Promote a task draft into spec tasks.md')
+    .requiredOption('--draft <draft-id>', 'Draft identifier')
+    .requiredOption('--spec <spec-id>', 'Spec identifier')
+    .option('--force', 'Override quality gate')
+    .option('--policy <path>', 'Task quality policy path override')
+    .option('--json', 'Print machine-readable JSON output')
+    .action(async (options) => {
+      try {
+        await runTaskPromoteCommand(options);
+      } catch (error) {
+        console.error(chalk.red(`Task promote failed: ${error.message}`));
+        process.exitCode = 1;
+      }
+    });
 }
 
 module.exports = {
@@ -780,5 +1047,9 @@ module.exports = {
   runTaskRefCommand,
   runTaskShowCommand,
   runTaskRerunCommand,
+  runTaskDraftCommand,
+  runTaskConsolidateCommand,
+  runTaskScoreCommand,
+  runTaskPromoteCommand,
   registerTaskCommands
 };

package/lib/task/task-quality-policy.js

@@ -0,0 +1,109 @@
+const fs = require('fs-extra');
+const path = require('path');
+
+const DEFAULT_POLICY_PATH = path.join('.sce', 'config', 'task-quality-policy.json');
+
+const DEFAULT_TASK_QUALITY_POLICY = Object.freeze({
+  schema_version: '1.0',
+  min_quality_score: 70,
+  require_acceptance_criteria: true,
+  allow_needs_split: false,
+  auto_suggest_acceptance: true,
+  max_sub_goals: 3
+});
+
+function normalizeText(value) {
+  if (typeof value !== 'string') {
+    return '';
+  }
+  return value.trim();
+}
+
+function normalizeBoolean(value, fallback) {
+  if (typeof value === 'boolean') {
+    return value;
+  }
+  const normalized = normalizeText(`${value || ''}`).toLowerCase();
+  if (!normalized) {
+    return fallback;
+  }
+  if (['1', 'true', 'yes', 'y', 'on'].includes(normalized)) {
+    return true;
+  }
+  if (['0', 'false', 'no', 'n', 'off'].includes(normalized)) {
+    return false;
+  }
+  return fallback;
+}
+
+function toPositiveInteger(value, fallback) {
+  const parsed = Number.parseInt(`${value}`, 10);
+  if (!Number.isFinite(parsed) || parsed <= 0) {
+    return fallback;
+  }
+  return parsed;
+}
+
+function normalizePolicy(payload = {}) {
+  const policy = payload && typeof payload === 'object' ? payload : {};
+  return {
+    schema_version: normalizeText(policy.schema_version) || DEFAULT_TASK_QUALITY_POLICY.schema_version,
+    min_quality_score: toPositiveInteger(
+      policy.min_quality_score,
+      DEFAULT_TASK_QUALITY_POLICY.min_quality_score
+    ),
+    require_acceptance_criteria: normalizeBoolean(
+      policy.require_acceptance_criteria,
+      DEFAULT_TASK_QUALITY_POLICY.require_acceptance_criteria
+    ),
+    allow_needs_split: normalizeBoolean(
+      policy.allow_needs_split,
+      DEFAULT_TASK_QUALITY_POLICY.allow_needs_split
+    ),
+    auto_suggest_acceptance: normalizeBoolean(
+      policy.auto_suggest_acceptance,
+      DEFAULT_TASK_QUALITY_POLICY.auto_suggest_acceptance
+    ),
+    max_sub_goals: toPositiveInteger(
+      policy.max_sub_goals,
+      DEFAULT_TASK_QUALITY_POLICY.max_sub_goals
+    )
+  };
+}
+
+async function loadTaskQualityPolicy(projectPath, policyPath, fileSystem = fs) {
+  const resolvedPath = normalizeText(policyPath) || DEFAULT_POLICY_PATH;
+  const absolutePath = path.isAbsolute(resolvedPath)
+    ? resolvedPath
+    : path.join(projectPath, resolvedPath);
+
+  if (!await fileSystem.pathExists(absolutePath)) {
+    return {
+      policy: normalizePolicy(DEFAULT_TASK_QUALITY_POLICY),
+      path: resolvedPath,
+      loaded_from: 'default'
+    };
+  }
+
+  try {
+    const payload = await fileSystem.readJson(absolutePath);
+    return {
+      policy: normalizePolicy(payload),
+      path: resolvedPath,
+      loaded_from: 'file'
+    };
+  } catch (_error) {
+    return {
+      policy: normalizePolicy(DEFAULT_TASK_QUALITY_POLICY),
+      path: resolvedPath,
+      loaded_from: 'default'
+    };
+  }
+}
+
+module.exports = {
+  DEFAULT_POLICY_PATH,
+  DEFAULT_TASK_QUALITY_POLICY,
+  normalizePolicy,
+  loadTaskQualityPolicy
+};