sdd-agent-platform 0.3.0 → 0.4.1

package/node_modules/@sdd-agent-platform/core/src/config/project-config.ts

@@ -0,0 +1,259 @@
+import { readFile } from 'node:fs/promises';
+import path from 'node:path';
+import { PROJECT_CONFIG_CONTRACT } from '../contracts.js';
+import { safeBranchOrNull } from '../path-safety.js';
+import { detectProject } from './project-detection.js';
+import type { DetectionConfidence } from './project-detection.js';
+import { getProjectConfigPath } from '../runtime-paths.js';
+
+export type ProjectLifecycleProfile = 'direct' | 'compact' | 'full' | 'research';
+
+export interface ProjectConfig<TAgentRuntimeConfig = unknown> {
+  contract: typeof PROJECT_CONFIG_CONTRACT;
+  project: {
+    name: string;
+    language: string;
+    framework: string;
+  };
+  detection?: {
+    confidence: DetectionConfidence;
+    mixed_stack: boolean;
+    primary: string;
+    candidates: Array<{
+      id: string;
+      confidence: DetectionConfidence;
+      score: number;
+    }>;
+  };
+  sdd: {
+    spec_dir: string;
+    default_branch?: string;
+    docs_language: string;
+    compatible_with: string;
+  };
+  validation: {
+    default: string[];
+  };
+  editing: {
+    prefer_hashline: boolean;
+    native_edit_fallback: boolean;
+  };
+  runtime: {
+    background_write: boolean;
+    worktree_isolation: boolean;
+    sync_back_mode: 'proposal';
+  };
+  lifecycle: {
+    decision_required: boolean;
+    profiles: ProjectLifecycleProfile[];
+  };
+  agentRuntime?: TAgentRuntimeConfig;
+}
+
+export async function detectProjectConfig<TAgentRuntimeConfig = unknown>(projectRoot: string, projectName: string): Promise<ProjectConfig<TAgentRuntimeConfig>> {
+  const config = defaultProjectConfig<TAgentRuntimeConfig>(projectName);
+  const detection = await detectProject(projectRoot);
+  config.project.language = detection.primary.language;
+  config.project.framework = detection.primary.framework;
+  config.validation.default = detection.primary.validationDefault;
+  config.detection = {
+    confidence: detection.primary.confidence,
+    mixed_stack: detection.mixed_stack,
+    primary: detection.primary.id,
+    candidates: detection.candidates.map((candidate) => ({
+      id: candidate.id,
+      confidence: candidate.confidence,
+      score: candidate.score
+    }))
+  };
+  return config;
+}
+
+export function defaultProjectConfig<TAgentRuntimeConfig = unknown>(projectName: string): ProjectConfig<TAgentRuntimeConfig> {
+  return {
+    contract: PROJECT_CONFIG_CONTRACT,
+    project: {
+      name: projectName,
+      language: 'typescript',
+      framework: 'node'
+    },
+    sdd: {
+      spec_dir: 'specs/<branch>',
+      default_branch: 'master',
+      docs_language: 'zh-CN',
+      compatible_with: 'spec-kit'
+    },
+    validation: {
+      default: ['npm run typecheck']
+    },
+    editing: {
+      prefer_hashline: true,
+      native_edit_fallback: true
+    },
+    runtime: {
+      background_write: false,
+      worktree_isolation: false,
+      sync_back_mode: 'proposal'
+    },
+    lifecycle: {
+      decision_required: true,
+      profiles: ['direct', 'compact', 'full', 'research']
+    }
+  };
+}
+
+export function renderProjectConfig(config: ProjectConfig<unknown>): string {
+  const detection = config.detection ? `detection:\n  confidence: ${config.detection.confidence}\n  mixed_stack: ${config.detection.mixed_stack}\n  primary: ${config.detection.primary}\n  candidates:\n${config.detection.candidates.map((candidate) => `    - id: ${candidate.id}\n      confidence: ${candidate.confidence}\n      score: ${candidate.score}`).join('\n')}\n` : '';
+  const defaultBranch = config.sdd.default_branch ? `  default_branch: ${config.sdd.default_branch}\n` : '';
+  return `contract: ${config.contract}\nproject:\n  name: ${config.project.name}\n  language: ${config.project.language}\n  framework: ${config.project.framework}\n${detection}sdd:\n  spec_dir: ${config.sdd.spec_dir}\n${defaultBranch}  # Project-level SDD document prose language; runtime CLI/JSON output remains English.\n  docs_language: ${config.sdd.docs_language}\n  compatible_with: ${config.sdd.compatible_with}\nvalidation:\n  default:\n${config.validation.default.map((command) => `    - ${command}`).join('\n')}\nediting:\n  prefer_hashline: ${config.editing.prefer_hashline}\n  native_edit_fallback: ${config.editing.native_edit_fallback}\nruntime:\n  background_write: ${config.runtime.background_write}\n  worktree_isolation: ${config.runtime.worktree_isolation}\n  sync_back_mode: ${config.runtime.sync_back_mode}\nlifecycle:\n  decision_required: ${config.lifecycle.decision_required}\n  profiles:\n${config.lifecycle.profiles.map((profile) => `    - ${profile}`).join('\n')}\n`;
+}
+
+export async function readProjectConfig<TAgentRuntimeConfig = unknown>(projectRoot: string, parseAgentRuntime?: (raw: string) => TAgentRuntimeConfig | undefined): Promise<ProjectConfig<TAgentRuntimeConfig>> {
+  const configPath = getProjectConfigPath(projectRoot);
+  const raw = await readFile(configPath, 'utf8');
+  return parseProjectConfig<TAgentRuntimeConfig>(raw, configPath, parseAgentRuntime);
+}
+
+export function parseProjectConfig<TAgentRuntimeConfig = unknown>(raw: string, configPath: string, parseAgentRuntime?: (raw: string) => TAgentRuntimeConfig | undefined): ProjectConfig<TAgentRuntimeConfig> {
+  const requiredSnippets = [
+    'contract: phase-1.2-project-contract',
+    'project:',
+    'sdd:',
+    'validation:',
+    'runtime:',
+    'lifecycle:'
+  ];
+  for (const snippet of requiredSnippets) {
+    if (!raw.includes(snippet)) {
+      throw new Error(`${configPath} missing required snippet: ${snippet}`);
+    }
+  }
+
+  const projectName = readScalar(raw, 'name') ?? path.basename(path.dirname(path.dirname(configPath)));
+  const language = readScalar(raw, 'language') ?? 'unknown';
+  const framework = readScalar(raw, 'framework') ?? 'unknown';
+  const specDir = readScalar(raw, 'spec_dir') ?? 'specs/<branch>';
+  const defaultBranch = safeBranchOrNull(readScalar(raw, 'default_branch') ?? '') ?? undefined;
+  const docsLanguage = readScalar(raw, 'docs_language') ?? 'zh-CN';
+  const compatibleWith = readScalar(raw, 'compatible_with') ?? 'spec-kit';
+  const defaultCommands = readListInSection(raw, 'validation', 'default');
+  const profiles = readListInSection(raw, 'lifecycle', 'profiles') as ProjectLifecycleProfile[];
+
+  return {
+    contract: PROJECT_CONFIG_CONTRACT,
+    project: {
+      name: projectName,
+      language,
+      framework
+    },
+    detection: parseDetection(raw),
+    sdd: {
+      spec_dir: specDir,
+      default_branch: defaultBranch,
+      docs_language: docsLanguage,
+      compatible_with: compatibleWith
+    },
+    validation: {
+      default: defaultCommands
+    },
+    editing: {
+      prefer_hashline: readBoolean(raw, 'prefer_hashline', true),
+      native_edit_fallback: readBoolean(raw, 'native_edit_fallback', true)
+    },
+    runtime: {
+      background_write: readBoolean(raw, 'background_write', false),
+      worktree_isolation: readBoolean(raw, 'worktree_isolation', false),
+      sync_back_mode: 'proposal'
+    },
+    lifecycle: {
+      decision_required: readBoolean(raw, 'decision_required', true),
+      profiles: profiles.length > 0 ? profiles : ['direct', 'compact', 'full', 'research']
+    },
+    agentRuntime: parseAgentRuntime?.(raw)
+  };
+}
+
+function parseDetection(raw: string): ProjectConfig['detection'] {
+  const primary = readScalar(raw, 'primary');
+  const confidence = readDetectionConfidence(readScalar(raw, 'confidence'));
+  if (!primary || !confidence) {
+    return undefined;
+  }
+  const candidateIds = readListFieldObjects(raw, 'candidates', 'id');
+  return {
+    confidence,
+    mixed_stack: readBoolean(raw, 'mixed_stack', false),
+    primary,
+    candidates: candidateIds.map((id) => ({
+      id,
+      confidence,
+      score: 0
+    }))
+  };
+}
+
+function readDetectionConfidence(value: string | null): DetectionConfidence | null {
+  return value === 'high' || value === 'medium' || value === 'low' ? value : null;
+}
+
+function readListFieldObjects(raw: string, section: string, field: string): string[] {
+  const lines = raw.split(/\r?\n/);
+  const sectionIndex = lines.findIndex((line) => line.trim() === `${section}:`);
+  if (sectionIndex < 0) {
+    return [];
+  }
+  const values: string[] = [];
+  for (let index = sectionIndex + 1; index < lines.length; index += 1) {
+    const line = lines[index];
+    if (line.trim().length === 0) {
+      continue;
+    }
+    if (!line.startsWith('    ') && !line.startsWith('  - ')) {
+      break;
+    }
+    const match = line.match(new RegExp(`^-?\\s*${field}:\\s*(.+?)\\s*$`));
+    const indentedMatch = line.trim().match(new RegExp(`^-?\\s*${field}:\\s*(.+?)\\s*$`));
+    const value = match?.[1] ?? indentedMatch?.[1];
+    if (value) {
+      values.push(value.trim());
+    }
+  }
+  return values;
+}
+
+function readScalar(raw: string, key: string): string | null {
+  const match = raw.match(new RegExp(`^\\s*${key}:\\s*(.+?)\\s*$`, 'm'));
+  return match?.[1]?.trim() ?? null;
+}
+
+function readBoolean(raw: string, key: string, defaultValue: boolean): boolean {
+  const value = readScalar(raw, key);
+  if (value === 'true') {
+    return true;
+  }
+  if (value === 'false') {
+    return false;
+  }
+  return defaultValue;
+}
+
+function readListInSection(raw: string, section: string, key: string): string[] {
+  const lines = raw.split(/\r?\n/);
+  const sectionIndex = lines.findIndex((line) => line.trim() === `${section}:`);
+  if (sectionIndex < 0) {
+    return [];
+  }
+  const keyIndex = lines.findIndex((line, index) => index > sectionIndex && line.trim() === `${key}:`);
+  if (keyIndex < 0) {
+    return [];
+  }
+  const items: string[] = [];
+  for (let index = keyIndex + 1; index < lines.length; index += 1) {
+    const line = lines[index];
+    if (!line.startsWith('    - ')) {
+      break;
+    }
+    items.push(line.slice('    - '.length).trim());
+  }
+  return items;
+}

package/node_modules/@sdd-agent-platform/core/src/config/project-detection.ts

@@ -0,0 +1,147 @@
+import { readdir, readFile, stat } from 'node:fs/promises';
+import path from 'node:path';
+
+export type DetectionConfidence = 'high' | 'medium' | 'low';
+
+export interface DetectionEvidence {
+  kind: string;
+  detail: string;
+  weight: number;
+}
+
+export interface ProjectDetectionCandidate {
+  id: string;
+  language: string;
+  framework: string;
+  score: number;
+  confidence: DetectionConfidence;
+  evidence: DetectionEvidence[];
+  validationDefault: string[];
+}
+
+export interface ProjectDetection {
+  primary: ProjectDetectionCandidate;
+  candidates: ProjectDetectionCandidate[];
+  mixed_stack: boolean;
+}
+
+interface ProjectDetector {
+  id: string;
+  detect(projectRoot: string, rootEntries: string[]): Promise<ProjectDetectionCandidate>;
+}
+
+const PROJECT_DETECTORS: ProjectDetector[] = [
+  {
+    id: 'java-ssm-maven-multimodule',
+    async detect(projectRoot, rootEntries) {
+      const hasPom = rootEntries.includes('pom.xml');
+      const pom = hasPom ? await readFile(path.join(projectRoot, 'pom.xml'), 'utf8') : '';
+      const javaFiles = await countFiles(projectRoot, (filePath) => filePath.endsWith('.java'), 100);
+      const springXmlFiles = await countFiles(projectRoot, (filePath) => filePath.endsWith('.xml') && filePath.includes('/src/main/') && /applicationContext|spring|dubbo|mybatis/i.test(path.basename(filePath)), 50);
+      const mybatisMapperFiles = await countFiles(projectRoot, (filePath) => filePath.endsWith('Mapper.xml'), 50);
+      const mavenMultimodule = /<packaging>\s*pom\s*<\/packaging>/i.test(pom) || /<modules>\s*<module>/is.test(pom);
+      const ssmScore = springXmlFiles + mybatisMapperFiles + (/spring|mybatis|dubbo/i.test(pom) ? 3 : 0);
+      const evidence = detectionEvidence([
+        { kind: 'pom.xml', detail: hasPom ? 'root pom.xml present' : '', weight: hasPom ? 6 : 0 },
+        { kind: 'maven_multimodule', detail: mavenMultimodule ? 'packaging pom or modules detected' : '', weight: mavenMultimodule ? 3 : 0 },
+        { kind: 'java_sources', detail: `${javaFiles} Java source file(s)`, weight: Math.min(javaFiles, 10) },
+        { kind: 'ssm_evidence', detail: `${ssmScore} Spring/MyBatis evidence point(s)`, weight: Math.min(ssmScore, 10) }
+      ]);
+      return detectionCandidate('java-ssm-maven-multimodule', 'java', mavenMultimodule || ssmScore > 0 ? 'ssm-maven-multimodule' : 'maven', evidence, ['mvn compile']);
+    }
+  },
+  {
+    id: 'typescript-node',
+    async detect(projectRoot, rootEntries) {
+      const hasPackageJson = rootEntries.includes('package.json');
+      const packageJson = hasPackageJson ? await readFile(path.join(projectRoot, 'package.json'), 'utf8') : '';
+      const tsFiles = await countFiles(projectRoot, (filePath) => filePath.endsWith('.ts') || filePath.endsWith('.tsx'), 100);
+      const nodeSourceDirs = rootEntries.filter((entry) => ['src', 'app', 'pages'].includes(entry)).length;
+      const typescriptEvidence = /typescript|tsx|ts-node|vite|next|nuxt/i.test(packageJson);
+      const evidence = detectionEvidence([
+        { kind: 'package.json', detail: hasPackageJson ? 'root package.json present' : '', weight: hasPackageJson ? 4 : 0 },
+        { kind: 'typescript_sources', detail: `${tsFiles} TypeScript source file(s)`, weight: Math.min(tsFiles, 10) },
+        { kind: 'typescript_package', detail: typescriptEvidence ? 'TypeScript-related package metadata detected' : '', weight: typescriptEvidence ? 3 : 0 },
+        { kind: 'node_source_dirs', detail: `${nodeSourceDirs} common Node source dir(s)`, weight: nodeSourceDirs }
+      ]);
+      return detectionCandidate('typescript-node', 'typescript', typescriptEvidence || tsFiles > 0 ? 'typescript-node' : 'node', evidence, ['npm run typecheck']);
+    }
+  }
+];
+
+export async function detectProject(projectRoot: string): Promise<ProjectDetection> {
+  const rootEntries = await safeReadDir(projectRoot);
+  const detected = await Promise.all(PROJECT_DETECTORS.map((detector) => detector.detect(projectRoot, rootEntries)));
+  const candidates = detected.filter((candidate) => candidate.score > 0).sort((left, right) => right.score - left.score);
+  const primary = candidates[0] ?? detectionCandidate('typescript-node', 'typescript', 'node', [], ['npm run typecheck']);
+  return {
+    primary,
+    candidates: candidates.length > 0 ? candidates : [primary],
+    mixed_stack: candidates.length > 1
+  };
+}
+
+function detectionEvidence(items: DetectionEvidence[]): DetectionEvidence[] {
+  return items.filter((item) => item.weight > 0);
+}
+
+function detectionCandidate(id: string, language: string, framework: string, evidence: DetectionEvidence[], validationDefault: string[]): ProjectDetectionCandidate {
+  const score = evidence.reduce((total, item) => total + item.weight, 0);
+  return {
+    id,
+    language,
+    framework,
+    score,
+    confidence: detectionConfidence(score),
+    evidence,
+    validationDefault
+  };
+}
+
+function detectionConfidence(score: number): DetectionConfidence {
+  if (score >= 10) {
+    return 'high';
+  }
+  if (score >= 5) {
+    return 'medium';
+  }
+  return 'low';
+}
+
+async function safeReadDir(directory: string): Promise<string[]> {
+  try {
+    return await readdir(directory);
+  } catch {
+    return [];
+  }
+}
+
+async function countFiles(root: string, predicate: (filePath: string) => boolean, limit: number): Promise<number> {
+  let count = 0;
+  const pending = [root];
+
+  while (pending.length > 0 && count < limit) {
+    const current = pending.pop() as string;
+    for (const entry of await safeReadDir(current)) {
+      if (['.git', 'node_modules', 'target', 'dist', '.sdd'].includes(entry)) {
+        continue;
+      }
+
+      const fullPath = path.join(current, entry);
+      const entryStat = await stat(fullPath).catch(() => null);
+      if (!entryStat) {
+        continue;
+      }
+      if (entryStat.isDirectory()) {
+        pending.push(fullPath);
+      } else if (predicate(fullPath.replace(/\\/g, '/'))) {
+        count += 1;
+        if (count >= limit) {
+          return count;
+        }
+      }
+    }
+  }
+
+  return count;
+}

package/node_modules/@sdd-agent-platform/core/src/config/project-status.ts

@@ -0,0 +1 @@
+export * from '../status/project-status.js';