draftgo-cli 3.0.39 → 3.0.43

package/src/context/index.js

@@ -0,0 +1,576 @@
+'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 LONG_CONTENT_RESOURCE_TYPES = Object.freeze([
+  'pages',
+  'navigations',
+  'docs/articles',
+]);
+const DB_META_LIST_PATH = '/api/db-meta';
+const DB_META_PAGE_SIZE = 100;
+const ROOT_SECTIONS = [
+  '核心边界',
+  '强制预读：Reference 优先于 MCP',
+  '并行开发与所有权',
+  '标准工作流',
+  '安全规则',
+  '验证与交付',
+];
+
+const TASK_PROFILES = Object.freeze({
+  frontend: {
+    apiQueries: [
+      { resource_type: 'pages' },
+      { resource_type: 'navigations' },
+      { resource_type: 'db' },
+    ],
+    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: {
+    apiQueries: [{ resource_type: 'db' }],
+    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': {
+    apiQueries: [{ resource_type: 'custom_scripts' }],
+    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: {
+    apiQueries: [
+      { resource_type: 'aihub' },
+      { resource_type: 'agents' },
+    ],
+    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: {
+    apiQueries: [
+      { resource_type: 'pages' },
+      { resource_type: 'navigations' },
+      { resource_type: 'docs/articles' },
+    ],
+    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: {
+    apiQueries: [
+      { resource_type: 'pages' },
+      { resource_type: 'navigations' },
+      { resource_type: 'docs/articles' },
+      { resource_type: 'db' },
+    ],
+    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 structuredValueFromRaw(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;
+  return value;
+}
+
+function nextCursorFromRaw(result) {
+  const value = structuredValueFromRaw(result);
+  if (!value || typeof value !== 'object') return null;
+  const hasMore = value.has_more === true || value.hasMore === true;
+  let cursor = null;
+  let hasCursor = false;
+  if (Object.prototype.hasOwnProperty.call(value, 'next_cursor')) {
+    cursor = value.next_cursor;
+    hasCursor = true;
+  } else if (Object.prototype.hasOwnProperty.call(value, 'nextCursor')) {
+    cursor = value.nextCursor;
+    hasCursor = true;
+  } else if (hasMore && Object.prototype.hasOwnProperty.call(value, 'cursor')) {
+    cursor = value.cursor;
+    hasCursor = true;
+  }
+  if (hasMore && (!hasCursor || cursor == null || cursor === '')) {
+    throw new Error('DraftGo MCP pagination reported more results without a cursor.');
+  }
+  return hasCursor ? cursor : null;
+}
+
+async function collectLongContentResources(session, server, options = {}) {
+  const sequences = await Promise.all(LONG_CONTENT_RESOURCE_TYPES.map((resourceType) =>
+    rawPagedQuery(
+      session,
+      TOOL_NAMES.resourceList,
+      { resource_type: resourceType, limit: 100 },
+      server,
+      options,
+    )));
+  return {
+    source: {
+      kind: 'mcp_tool_batch',
+      server,
+      canonical_tool: TOOL_NAMES.resourceList,
+      arguments: LONG_CONTENT_RESOURCE_TYPES.map((resourceType) => ({
+        resource_type: resourceType,
+        limit: 100,
+      })),
+    },
+    pages: sequences.flatMap((sequence) => sequence.pages),
+  };
+}
+
+async function collectTaskAPIs(session, queries, server, options = {}) {
+  const argumentsList = queries.map((query) => ({ ...query, limit: 100 }));
+  const sequences = await Promise.all(argumentsList.map((args) =>
+    rawPagedQuery(session, TOOL_NAMES.apiSearch, args, server, options)));
+  return {
+    source: {
+      kind: 'mcp_tool_batch',
+      server,
+      canonical_tool: TOOL_NAMES.apiSearch,
+      arguments: argumentsList,
+    },
+    pages: sequences.flatMap((sequence) => sequence.pages),
+  };
+}
+
+function itemsFromRawSequence(sequence) {
+  if (!sequence || !Array.isArray(sequence.pages)) return [];
+  return sequence.pages.flatMap((page) => {
+    const value = structuredValueFromRaw(page);
+    if (Array.isArray(value)) return value;
+    if (value && Array.isArray(value.items)) return value.items;
+    if (value && Array.isArray(value.operations)) return value.operations;
+    return [];
+  });
+}
+
+function selectDBMetaListOperation(sequence) {
+  return itemsFromRawSequence(sequence).find((operation) => {
+    if (!operation || typeof operation !== 'object') return false;
+    const method = String(operation.method || '').trim().toUpperCase();
+    const resourceType = String(operation.resource_type || '').trim().toLowerCase();
+    const operationPath = String(operation.path || operation.path_template || '').trim();
+    return method === 'GET'
+      && resourceType === 'db_meta'
+      && operationPath === DB_META_LIST_PATH
+      && operation.destructive !== true;
+  }) || null;
+}
+
+function optionalPageInteger(value, field, minimum) {
+  if (value == null) return null;
+  if (!Number.isSafeInteger(value) || value < minimum) {
+    throw new Error(`DraftGo db_meta API returned invalid ${field}.`);
+  }
+  return value;
+}
+
+function dbMetaPageInfo(response) {
+  let value = structuredValueFromRaw(response);
+  if (value && value.response) value = value.response;
+  if (value && value.data) value = value.data;
+  if (!value || typeof value !== 'object' || !Array.isArray(value.items)) return null;
+  return {
+    items: value.items,
+    total: optionalPageInteger(value.total, 'total', 0),
+    page: optionalPageInteger(value.page, 'page', 1),
+    pageSize: optionalPageInteger(value.page_size, 'page_size', 1),
+  };
+}
+
+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 collectDBMetaResources(session, operationID, server, options = {}) {
+  const pages = [];
+  let fetchedItems = 0;
+  let reportedTotal = null;
+  const maxPages = options.maxPages == null ? 100 : Number(options.maxPages);
+  if (!Number.isSafeInteger(maxPages) || maxPages < 1) {
+    throw new TypeError('maxPages must be a positive integer.');
+  }
+  for (let page = 1; page <= maxPages; page += 1) {
+    const args = {
+      operation_id: operationID,
+      query: { page, page_size: DB_META_PAGE_SIZE },
+    };
+    const response = await rawQuery(session, TOOL_NAMES.apiCall, args, server, options);
+    pages.push(response);
+    const info = dbMetaPageInfo(response);
+    if (!info) {
+      return {
+        source: {
+          kind: 'mcp_tool_sequence',
+          server,
+          canonical_tool: TOOL_NAMES.apiCall,
+          operation_id: operationID,
+        },
+        pages,
+        pagination: { complete: false, reason: 'response_shape_unavailable' },
+      };
+    }
+    const responsePage = info.page || page;
+    const responsePageSize = info.pageSize || DB_META_PAGE_SIZE;
+    if (responsePage !== page) {
+      throw new Error(`DraftGo db_meta API returned page ${responsePage} while page ${page} was requested.`);
+    }
+    fetchedItems += info.items.length;
+    if (info.total != null) {
+      if (reportedTotal != null && info.total !== reportedTotal) {
+        throw new Error(`DraftGo db_meta API changed total from ${reportedTotal} to ${info.total} during pagination.`);
+      }
+      reportedTotal = info.total;
+    }
+    if (reportedTotal != null) {
+      if (fetchedItems >= reportedTotal) {
+        return {
+          source: {
+            kind: 'mcp_tool_sequence',
+            server,
+            canonical_tool: TOOL_NAMES.apiCall,
+            operation_id: operationID,
+          },
+          pages,
+          pagination: { complete: true, total: reportedTotal },
+        };
+      }
+      if (!info.items.length) {
+        throw new Error('DraftGo db_meta API ended before the reported total was reached.');
+      }
+    } else if (info.items.length < responsePageSize) {
+      return {
+        source: {
+          kind: 'mcp_tool_sequence',
+          server,
+          canonical_tool: TOOL_NAMES.apiCall,
+          operation_id: operationID,
+        },
+        pages,
+        pagination: { complete: true, total: null },
+      };
+    }
+  }
+  throw new Error(`DraftGo db_meta API exceeded ${maxPages} pages.`);
+}
+
+async function collectDataStructures(session, server, options = {}) {
+  const api = await rawPagedQuery(
+    session,
+    TOOL_NAMES.apiSearch,
+    { resource_type: 'db_meta', limit: 100 },
+    server,
+    options,
+  );
+  const operation = selectDBMetaListOperation(api);
+  if (!operation || !operation.operation_id) {
+    throw new Error('DraftGo MCP does not expose a read-only GET /api/db-meta operation.');
+  }
+  const operationID = String(operation.operation_id);
+  const [contract, resources] = await Promise.all([
+    rawQuery(
+      session,
+      TOOL_NAMES.apiDescribe,
+      { operation_id: operationID },
+      server,
+      options,
+    ),
+    collectDBMetaResources(session, operationID, server, options),
+  ]);
+  return { api, contract, resources };
+}
+
+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,
+    TOOL_NAMES.apiDescribe,
+    TOOL_NAMES.apiCall,
+  ];
+  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),
+      collectLongContentResources(session, config.server, queryOptions),
+      collectTaskAPIs(session, profile.apiQueries, 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.1',
+    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,
+  structuredValueFromRaw,
+  nextCursorFromRaw,
+  rawPagedQuery,
+  collectLongContentResources,
+  collectTaskAPIs,
+  itemsFromRawSequence,
+  selectDBMetaListOperation,
+  dbMetaPageInfo,
+  collectDBMetaResources,
+  collectDataStructures,
+  readInstalledSkillVersion,
+  collectContext,
+};