draftgo-cli 3.0.39 → 3.0.41

package/src/context/index.js

@@ -0,0 +1,368 @@
+'use strict';
+
+const crypto = require('crypto');
+const fs = require('fs');
+const path = require('path');
+const pkg = require('../../package.json');
+const { RESOURCES_DIR } = require('../paths');
+const { loadProjectConfig } = require('../projectConfig');
+const { TOOL_NAMES, openToolSession } = require('../mcp/tools');
+const { readInstalledVersion } = require('../skill');
+
+const SKILL_ROOT = path.join(RESOURCES_DIR, 'skill');
+const MAX_STRUCTURED_TEXT_BYTES = 1024 * 1024;
+const ROOT_SECTIONS = [
+  '核心边界',
+  '强制预读：Reference 优先于 MCP',
+  '并行开发与所有权',
+  '标准工作流',
+  '安全规则',
+  '验证与交付',
+];
+
+const TASK_PROFILES = Object.freeze({
+  frontend: {
+    apiQuery: 'frontend pages navigation',
+    references: [
+      { file: 'SKILL.md', headings: ROOT_SECTIONS },
+      { file: 'references/architecture.md' },
+      { file: 'references/modules.md' },
+      { file: 'references/frontend.md' },
+      { file: 'references/runtime.md' },
+      { file: 'references/app-api.md' },
+      { file: 'references/security.md' },
+      { file: 'references/checkout.md' },
+      { file: 'references/parallel.md' },
+    ],
+  },
+  data: {
+    apiQuery: 'db_meta schema data',
+    references: [
+      { file: 'SKILL.md', headings: ROOT_SECTIONS },
+      { file: 'references/modules.md' },
+      { file: 'references/data.md' },
+      { file: 'references/db-relations.md' },
+      { file: 'references/security.md' },
+      { file: 'references/mcp.md', headings: ['边界', '协议与安全'] },
+      { file: 'references/parallel.md' },
+    ],
+  },
+  'custom-service': {
+    apiQuery: 'custom services routes permissions',
+    references: [
+      { file: 'SKILL.md', headings: ROOT_SECTIONS },
+      { file: 'references/modules.md' },
+      { file: 'references/custom-services.md' },
+      { file: 'references/data.md' },
+      { file: 'references/security.md' },
+      { file: 'references/parallel.md' },
+    ],
+  },
+  aihub: {
+    apiQuery: 'AIHub agents chat',
+    references: [
+      { file: 'SKILL.md', headings: ROOT_SECTIONS },
+      { file: 'references/aihub.md' },
+      { file: 'references/chat-sdk.md' },
+      { file: 'references/security.md' },
+      { file: 'references/parallel.md' },
+    ],
+  },
+  content: {
+    apiQuery: 'pages navigations docs',
+    references: [
+      { file: 'SKILL.md', headings: ROOT_SECTIONS },
+      { file: 'references/architecture.md' },
+      { file: 'references/modules.md' },
+      { file: 'references/checkout.md' },
+      { file: 'references/security.md' },
+      { file: 'references/parallel.md' },
+    ],
+  },
+  project: {
+    apiQuery: 'project resources',
+    references: [
+      { file: 'SKILL.md', headings: ROOT_SECTIONS },
+      { file: 'references/architecture.md' },
+      { file: 'references/modules.md' },
+      { file: 'references/mcp.md' },
+      { file: 'references/checkout.md' },
+      { file: 'references/parallel.md' },
+    ],
+  },
+});
+
+const TASK_ALIASES = Object.freeze({
+  backend: 'custom-service',
+  service: 'custom-service',
+  ui: 'frontend',
+});
+
+function normalizeTask(value) {
+  const requested = String(value || '').trim().toLowerCase();
+  const task = Object.prototype.hasOwnProperty.call(TASK_ALIASES, requested)
+    ? TASK_ALIASES[requested]
+    : requested;
+  if (!Object.prototype.hasOwnProperty.call(TASK_PROFILES, task)) {
+    const supported = Object.keys(TASK_PROFILES).join(', ');
+    throw new Error(`Unsupported context task: ${requested || '(empty)'}. Supported tasks: ${supported}.`);
+  }
+  return task;
+}
+
+function lineNumberAt(source, offset) {
+  let line = 1;
+  for (let index = 0; index < offset; index += 1) {
+    if (source.charCodeAt(index) === 10) line += 1;
+  }
+  return line;
+}
+
+function sectionEndLine(content, startLine) {
+  let newlines = 0;
+  for (let index = 0; index < content.length; index += 1) {
+    if (content.charCodeAt(index) === 10) newlines += 1;
+  }
+  return startLine + newlines - (content.endsWith('\n') ? 1 : 0);
+}
+
+function extractSections(source, requestedHeadings, sourcePath) {
+  const matches = [...source.matchAll(/^## ([^\r\n]+)\r?$/gm)];
+  const wanted = requestedHeadings ? new Set(requestedHeadings) : null;
+  const sections = [];
+
+  if (matches.length && matches[0].index > 0) {
+    const content = source.slice(0, matches[0].index);
+    const title = content.match(/^# ([^\r\n]+)\r?$/m);
+    sections.push({
+      source: {
+        kind: 'bundled_reference',
+        path: sourcePath,
+        heading: title ? title[1] : '(preamble)',
+        line_start: 1,
+        line_end: sectionEndLine(content, 1),
+        sha256: crypto.createHash('sha256').update(content, 'utf8').digest('hex'),
+      },
+      content,
+    });
+  }
+
+  for (let index = 0; index < matches.length; index += 1) {
+    const match = matches[index];
+    const heading = match[1];
+    if (wanted && !wanted.has(heading)) continue;
+    const start = match.index;
+    const end = index + 1 < matches.length ? matches[index + 1].index : source.length;
+    const content = source.slice(start, end);
+    const startLine = lineNumberAt(source, start);
+    sections.push({
+      source: {
+        kind: 'bundled_reference',
+        path: sourcePath,
+        heading,
+        line_start: startLine,
+        line_end: sectionEndLine(content, startLine),
+        sha256: crypto.createHash('sha256').update(content, 'utf8').digest('hex'),
+      },
+      content,
+    });
+  }
+
+  if (wanted) {
+    const found = new Set(matches.map((match) => match[1]));
+    const missing = requestedHeadings.filter((heading) => !found.has(heading));
+    if (missing.length) {
+      throw new Error(`${sourcePath} is missing required sections: ${missing.join(', ')}.`);
+    }
+  }
+  if (!sections.length) throw new Error(`${sourcePath} contains no selectable reference sections.`);
+  return sections;
+}
+
+function readTaskReferences(taskValue, options = {}) {
+  const task = normalizeTask(taskValue);
+  const skillRoot = options.skillRoot || SKILL_ROOT;
+  return TASK_PROFILES[task].references.flatMap((entry) => {
+    const absolute = path.join(skillRoot, entry.file);
+    const source = fs.readFileSync(absolute, 'utf8');
+    const sourcePath = path.posix.join('resources/skill', entry.file.replace(/\\/g, '/'));
+    return extractSections(source, entry.headings, sourcePath);
+  });
+}
+
+function rawQuery(session, expectedName, args, server, options = {}) {
+  const tool = session.names[expectedName] || expectedName;
+  return session.client.toolsCall(tool, args, options).then((result) => ({
+    source: {
+      kind: 'mcp_tool',
+      server,
+      tool,
+      canonical_tool: expectedName,
+      arguments: args,
+    },
+    result,
+  }));
+}
+
+function nextCursorFromRaw(result) {
+  let value = result;
+  if (value && value.result) value = value.result;
+  if (value && value.structuredContent) value = value.structuredContent;
+  else if (value && value.structured_content) value = value.structured_content;
+  else if (value && Array.isArray(value.content)) {
+    const text = value.content.find((part) =>
+      part && part.type === 'text' && typeof part.text === 'string');
+    if (text) {
+      if (Buffer.byteLength(text.text, 'utf8') > MAX_STRUCTURED_TEXT_BYTES) {
+        throw new Error('DraftGo MCP pagination result exceeded the structured JSON limit.');
+      }
+      try {
+        value = JSON.parse(text.text);
+      } catch {
+        throw new Error('DraftGo MCP pagination result did not contain structured JSON.');
+      }
+    }
+  }
+  if (value && value.data) value = value.data;
+  if (value && Object.prototype.hasOwnProperty.call(value, 'value')) value = value.value;
+  if (!value || typeof value !== 'object') return null;
+  if (Object.prototype.hasOwnProperty.call(value, 'next_cursor')) return value.next_cursor;
+  if (Object.prototype.hasOwnProperty.call(value, 'nextCursor')) return value.nextCursor;
+  return value.has_more && Object.prototype.hasOwnProperty.call(value, 'cursor')
+    ? value.cursor
+    : null;
+}
+
+async function rawPagedQuery(session, expectedName, baseArgs, server, options = {}) {
+  const pages = [];
+  const seen = new Set();
+  const maxPages = options.maxPages == null ? 100 : Number(options.maxPages);
+  if (!Number.isSafeInteger(maxPages) || maxPages < 1) {
+    throw new TypeError('maxPages must be a positive integer.');
+  }
+  let cursor = null;
+
+  for (let page = 0; page < maxPages; page += 1) {
+    const args = cursor == null ? { ...baseArgs } : { ...baseArgs, cursor };
+    const response = await rawQuery(session, expectedName, args, server, options);
+    pages.push(response);
+    const next = nextCursorFromRaw(response.result);
+    if (next == null || next === '') {
+      return {
+        source: {
+          kind: 'mcp_tool_sequence',
+          server,
+          canonical_tool: expectedName,
+          arguments: baseArgs,
+        },
+        pages,
+      };
+    }
+    const key = String(next);
+    if (seen.has(key)) throw new Error(expectedName + ' repeated a cursor.');
+    seen.add(key);
+    cursor = next;
+  }
+  throw new Error(expectedName + ' exceeded ' + maxPages + ' pages.');
+}
+
+async function collectDataStructures(session, server, options = {}) {
+  const [resources, api] = await Promise.all([
+    rawPagedQuery(
+      session,
+      TOOL_NAMES.resourceList,
+      { resource_type: 'db_meta' },
+      server,
+      options,
+    ),
+    rawQuery(
+      session,
+      TOOL_NAMES.apiSearch,
+      { query: 'db_meta schema' },
+      server,
+      options,
+    ),
+  ]);
+  return { resources, api };
+}
+
+async function collectContext(projectDir, taskValue, options = {}) {
+  const task = normalizeTask(taskValue);
+  const profile = TASK_PROFILES[task];
+  const references = readTaskReferences(task, options);
+  const installedSkillVersion = readInstalledSkillVersion(projectDir);
+  const config = options.config || loadProjectConfig(projectDir);
+  const expected = [TOOL_NAMES.projectOverview, TOOL_NAMES.resourceList, TOOL_NAMES.apiSearch];
+  const openSession = options.openToolSession || openToolSession;
+  const session = options.session || await openSession(config, expected, options);
+  const controller = new AbortController();
+  const externalSignal = options.signal;
+  const forwardAbort = () => controller.abort(externalSignal.reason);
+  if (externalSignal) {
+    if (externalSignal.aborted) forwardAbort();
+    else externalSignal.addEventListener('abort', forwardAbort, { once: true });
+  }
+
+  let project;
+  let resources;
+  let api;
+  let dataStructures;
+  try {
+    const queryOptions = { ...options, signal: controller.signal };
+    [project, resources, api, dataStructures] = await Promise.all([
+      rawQuery(session, TOOL_NAMES.projectOverview, {}, config.server, queryOptions),
+      rawPagedQuery(session, TOOL_NAMES.resourceList, {}, config.server, queryOptions),
+      rawQuery(
+        session,
+        TOOL_NAMES.apiSearch,
+        { query: profile.apiQuery },
+        config.server,
+        queryOptions,
+      ),
+      collectDataStructures(session, config.server, queryOptions),
+    ]);
+  } catch (error) {
+    if (!controller.signal.aborted) controller.abort(error);
+    throw error;
+  } finally {
+    if (externalSignal) externalSignal.removeEventListener('abort', forwardAbort);
+  }
+
+  return {
+    schema_version: '1.0',
+    task,
+    reference_bundle: {
+      source: 'draftgo-cli',
+      version: pkg.version,
+      installed_skill_version: installedSkillVersion,
+      synchronized: installedSkillVersion == null ? null : installedSkillVersion === pkg.version,
+    },
+    references,
+    live: {
+      session: {
+        server: config.server,
+        protocol_version: session.client.protocolVersion,
+      },
+      project,
+      resources,
+      api,
+      data_structures: dataStructures,
+    },
+  };
+}
+
+function readInstalledSkillVersion(projectDir) {
+  return readInstalledVersion(projectDir);
+}
+
+module.exports = {
+  TASK_PROFILES,
+  normalizeTask,
+  extractSections,
+  readTaskReferences,
+  nextCursorFromRaw,
+  rawPagedQuery,
+  collectDataStructures,
+  readInstalledSkillVersion,
+  collectContext,
+};

package/src/skill.js

@@ -9,6 +9,7 @@
 //   {{SKILL_DIR}}     → platform's project-relative skill dir (forward slashes)
 //   {{SKILL_SCRIPTS}} → {{SKILL_DIR}}/scripts
 
+const crypto = require('crypto');
 const path = require('path');
 const fs = require('fs');
 const { RESOURCES_DIR } = require('./paths');
@@ -19,6 +20,8 @@ const {
 } = require('./fsx');
 
 const SKILL_SOURCE_DIR = path.join(RESOURCES_DIR, 'skill');
+const MAX_VERSION_FILE_BYTES = 128;
+const VERSION_PATTERN = /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?(?:\+[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?$/;
 
 function getPackageVersion() {
   try {
@@ -29,12 +32,71 @@ function getPackageVersion() {
 }
 
 function readInstalledVersion(projectDir) {
-  const f = paths.versionFile(projectDir);
-  return exists(f) ? readText(f).trim() : null;
+  const file = paths.versionFile(projectDir);
+  let linkStat;
+  try {
+    linkStat = fs.lstatSync(file);
+  } catch (error) {
+    if (error && error.code === 'ENOENT') return null;
+    throw error;
+  }
+  if (linkStat.isSymbolicLink() || !linkStat.isFile()) {
+    throw new Error('Invalid .draftgo/.version: expected a regular file.');
+  }
+
+  let descriptor;
+  let raw;
+  try {
+    const noFollow = Number.isInteger(fs.constants.O_NOFOLLOW) ? fs.constants.O_NOFOLLOW : 0;
+    descriptor = fs.openSync(file, fs.constants.O_RDONLY | noFollow);
+    const stat = fs.fstatSync(descriptor);
+    if (!stat.isFile() || stat.size > MAX_VERSION_FILE_BYTES) {
+      throw new Error('Invalid .draftgo/.version: file is too large or not regular.');
+    }
+    const buffer = Buffer.alloc(MAX_VERSION_FILE_BYTES + 1);
+    const bytes = fs.readSync(descriptor, buffer, 0, buffer.length, 0);
+    if (bytes > MAX_VERSION_FILE_BYTES) {
+      throw new Error('Invalid .draftgo/.version: file exceeds 128 bytes.');
+    }
+    raw = buffer.subarray(0, bytes).toString('utf8');
+  } catch (error) {
+    if (error && error.code === 'ELOOP') {
+      throw new Error('Invalid .draftgo/.version: symbolic links are not allowed.');
+    }
+    throw error;
+  } finally {
+    if (descriptor !== undefined) fs.closeSync(descriptor);
+  }
+
+  const version = raw.trim();
+  const validLineEnding = raw === version || raw === `${version}\n` || raw === `${version}\r\n`;
+  if (!validLineEnding || !VERSION_PATTERN.test(version)) {
+    throw new Error('Invalid .draftgo/.version: expected one semantic version.');
+  }
+  return version;
 }
 
 function writeInstalledVersion(projectDir) {
-  writeText(paths.versionFile(projectDir), getPackageVersion() + '\n');
+  const file = paths.versionFile(projectDir);
+  ensureDir(path.dirname(file));
+  const temporary = path.join(
+    path.dirname(file),
+    `.${path.basename(file)}.${process.pid}.${crypto.randomBytes(8).toString('hex')}.tmp`,
+  );
+  let descriptor;
+  try {
+    descriptor = fs.openSync(temporary, 'wx', 0o600);
+    fs.writeFileSync(descriptor, getPackageVersion() + '\n', 'utf8');
+    fs.fsyncSync(descriptor);
+    fs.closeSync(descriptor);
+    descriptor = undefined;
+    fs.renameSync(temporary, file);
+  } finally {
+    if (descriptor !== undefined) {
+      try { fs.closeSync(descriptor); } catch { /* Preserve the original failure. */ }
+    }
+    try { fs.rmSync(temporary, { force: true }); } catch { /* Best-effort cleanup. */ }
+  }
 }
 
 function renderFrontmatter(fm) {