draftgo-cli 3.0.33 → 3.0.38

package/src/worktree/index.js

@@ -0,0 +1,461 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const { spawnSync } = require('child_process');
+const { loadProjectConfig } = require('../projectConfig');
+const { DraftGoMcpClient } = require('../mcp/client');
+const backendDefaults = require('./backend');
+const { WorktreeError, isVersionConflict } = require('./errors');
+const {
+  RESOURCE_TYPES,
+  canonicalResourceType,
+  entryKey,
+  mediaType,
+  resourceFileName,
+  safeIdSegment,
+} = require('./types');
+const { streamToFiles, hashFile, copyFileAtomic, writeJsonAtomic, normalizeSha256 } = require('./streams');
+const {
+  loadManifest,
+  getEntry,
+  relativePath,
+  absolutePath,
+  saveManifest,
+} = require('./manifest');
+const { validateContentFile } = require('./validate');
+
+const CONFLICT_SCHEMA_VERSION = 1;
+
+function backendFor(options) {
+  return { ...backendDefaults, ...(options.backend || {}) };
+}
+
+function worktreePaths(projectDir, resourceType, resourceId, extension) {
+  const canonical = canonicalResourceType(resourceType);
+  const directory = RESOURCE_TYPES[canonical].directory;
+  const fileName = resourceFileName(canonical, resourceId, extension);
+  return {
+    local: path.join(projectDir, '.draftgo', 'worktree', directory, fileName),
+    base: path.join(projectDir, '.draftgo', 'worktree', '.base', directory, fileName),
+  };
+}
+
+function conflictPaths(projectDir, resourceType, resourceId, extension) {
+  const canonical = canonicalResourceType(resourceType);
+  const directory = RESOURCE_TYPES[canonical].directory;
+  const root = path.join(projectDir, '.draftgo', 'conflicts', directory, safeIdSegment(resourceId));
+  return {
+    root,
+    manifest: path.join(root, 'conflict.json'),
+    base: path.join(root, `base${extension}`),
+    local: path.join(root, `local${extension}`),
+    remote: path.join(root, `remote${extension}`),
+  };
+}
+
+async function createSession(config, options) {
+  if (options.session) return options.session;
+  if (options.backend && typeof options.backend.resolveMetadata === 'function') return {};
+  const client = options.client || new DraftGoMcpClient(config);
+  await client.initialize(options);
+  const tools = await client.listAllTools(options);
+  return { client, tools };
+}
+
+function ensureIds(resourceIds) {
+  const ids = resourceIds.map((value) => String(value).trim()).filter(Boolean);
+  if (!ids.length) throw new WorktreeError('INVALID_RESOURCE_ID', 'At least one resource id is required.');
+  return ids;
+}
+
+function responseContentType(response) {
+  return mediaType(response && response.headers && response.headers.get('content-type'));
+}
+
+function assertMetadataIdentity(metadata, resourceType, resourceId) {
+  if (metadata.resource_type !== resourceType || String(metadata.resource_id) !== String(resourceId)) {
+    throw new WorktreeError('METADATA_RESOURCE_MISMATCH',
+      'DraftGo returned metadata for a different resource.');
+  }
+}
+
+async function checkoutResources(projectDir, resourceType, resourceIds, options = {}) {
+  const canonical = canonicalResourceType(resourceType);
+  const ids = ensureIds(resourceIds);
+  const config = options.config || loadProjectConfig(projectDir);
+  const backend = backendFor(options);
+  const session = await createSession(config, options);
+  const manifest = loadManifest(projectDir);
+  const results = [];
+
+  for (const resourceId of ids) {
+    const metadata = await backend.resolveMetadata(config, canonical, resourceId, {
+      ...options,
+      ...session,
+      clientInitialized: true,
+    });
+    assertMetadataIdentity(metadata, canonical, resourceId);
+
+    const existing = getEntry(manifest, canonical, resourceId);
+    if (existing) {
+      const existingLocal = absolutePath(projectDir, existing.local_path);
+      if (fs.existsSync(existingLocal)) {
+        const current = await hashFile(existingLocal);
+        if (current.hash !== existing.base_hash && !options.force) {
+          throw new WorktreeError(
+            'LOCAL_CHANGES_PRESENT',
+            `Refusing to replace locally modified ${canonical} ${resourceId}; commit it or use checkout --force explicitly.`,
+          );
+        }
+      }
+    }
+
+    const paths = worktreePaths(projectDir, canonical, resourceId, metadata.file_extension);
+    const response = await backend.download(config, metadata, options);
+    const actualType = responseContentType(response);
+    if (actualType && actualType !== mediaType(metadata.content_type)) {
+      throw new WorktreeError('CONTENT_TYPE_MISMATCH', 'Downloaded content type differs from checkout metadata.', {
+        expected: metadata.content_type,
+        actual: response.headers.get('content-type'),
+      });
+    }
+    const downloaded = await streamToFiles(response.body, [paths.local, paths.base], {
+      expectedHash: metadata.content_hash,
+      expectedSize: metadata.content_size,
+    });
+
+    const entry = {
+      server: config.server,
+      resource_type: canonical,
+      resource_id: resourceId,
+      title: metadata.title,
+      route: metadata.route,
+      code: metadata.code,
+      slug: metadata.slug,
+      local_path: relativePath(projectDir, paths.local),
+      content_type: metadata.content_type,
+      file_extension: metadata.file_extension,
+      content_size: downloaded.size,
+      base_path: relativePath(projectDir, paths.base),
+      base_version: metadata.base_version,
+      base_revision: metadata.base_revision,
+      base_etag: metadata.etag,
+      base_hash: downloaded.hash,
+      checked_out_at: new Date().toISOString(),
+      updated_at: metadata.updated_at,
+      updated_by: metadata.updated_by,
+    };
+    manifest.entries[entryKey(canonical, resourceId)] = entry;
+    await saveManifest(projectDir, manifest);
+    results.push(entry);
+  }
+  return results;
+}
+
+function normalizeCommitPayload(value) {
+  if (!value || typeof value !== 'object') return {};
+  if (value.data && typeof value.data === 'object') return normalizeCommitPayload(value.data);
+  if (value.metadata && typeof value.metadata === 'object') return normalizeCommitPayload(value.metadata);
+  if (value.resource && typeof value.resource === 'object') return normalizeCommitPayload(value.resource);
+  return value;
+}
+
+function commitVersion(payload) {
+  return {
+    version: payload.base_version !== undefined ? payload.base_version
+      : (payload.version !== undefined ? payload.version : null),
+    revision: payload.base_revision !== undefined ? payload.base_revision
+      : (payload.revision !== undefined ? payload.revision : null),
+    etag: payload.etag || payload.e_tag || null,
+    hash: normalizeSha256(payload.content_hash || payload.hash || payload.sha256),
+    updated_at: payload.updated_at || null,
+    updated_by: payload.updated_by || null,
+  };
+}
+
+async function writeConflict(projectDir, entry, error, config, backend, options, session) {
+  const localPath = absolutePath(projectDir, entry.local_path);
+  const basePath = absolutePath(projectDir, entry.base_path);
+  const paths = conflictPaths(projectDir, entry.resource_type, entry.resource_id, entry.file_extension);
+  const remoteMetadata = await backend.resolveMetadata(config, entry.resource_type, entry.resource_id, {
+    ...options,
+    ...session,
+    clientInitialized: true,
+  });
+  assertMetadataIdentity(remoteMetadata, entry.resource_type, entry.resource_id);
+  const response = await backend.download(config, remoteMetadata, options);
+
+  await copyFileAtomic(basePath, paths.base, { expectedHash: entry.base_hash });
+  const local = await copyFileAtomic(localPath, paths.local);
+  const remote = await streamToFiles(response.body, [paths.remote], {
+    expectedHash: remoteMetadata.content_hash,
+    expectedSize: remoteMetadata.content_size,
+  });
+
+  const record = {
+    schema_version: CONFLICT_SCHEMA_VERSION,
+    status: 'unresolved',
+    code: 'RESOURCE_VERSION_CONFLICT',
+    server: config.server,
+    resource_type: entry.resource_type,
+    resource_id: entry.resource_id,
+    title: entry.title,
+    content_type: entry.content_type,
+    base_path: relativePath(projectDir, paths.base),
+    local_path: relativePath(projectDir, paths.local),
+    remote_path: relativePath(projectDir, paths.remote),
+    worktree_local_path: entry.local_path,
+    expected_version: entry.base_version != null ? entry.base_version : entry.base_revision,
+    actual_version: remoteMetadata.base_version != null
+      ? remoteMetadata.base_version : remoteMetadata.base_revision,
+    expected_hash: entry.base_hash,
+    local_hash: local.hash,
+    actual_hash: remote.hash,
+    actual_base_version: remoteMetadata.base_version,
+    actual_base_revision: remoteMetadata.base_revision,
+    actual_etag: remoteMetadata.etag,
+    updated_at: remoteMetadata.updated_at,
+    updated_by: remoteMetadata.updated_by,
+    backend_error: {
+      status: error.status || null,
+      code: error.code || 'RESOURCE_VERSION_CONFLICT',
+    },
+    created_at: new Date().toISOString(),
+  };
+  await writeJsonAtomic(paths.manifest, record);
+  return { ...record, manifest_path: relativePath(projectDir, paths.manifest) };
+}
+
+function unresolvedConflict(projectDir, resourceType, resourceId) {
+  const entry = loadManifest(projectDir).entries[entryKey(resourceType, resourceId)];
+  const extension = entry && entry.file_extension || '.bin';
+  const file = conflictPaths(projectDir, resourceType, resourceId, extension).manifest;
+  if (!fs.existsSync(file)) return null;
+  try {
+    const record = JSON.parse(fs.readFileSync(file, 'utf8'));
+    return record.status === 'unresolved' ? record : null;
+  } catch (error) {
+    throw new WorktreeError('INVALID_CONFLICT_MANIFEST', `Invalid conflict manifest: ${error.message}`);
+  }
+}
+
+async function commitResources(projectDir, resourceType, resourceIds, options = {}) {
+  const canonical = canonicalResourceType(resourceType);
+  const ids = ensureIds(resourceIds);
+  const config = options.config || loadProjectConfig(projectDir);
+  const backend = backendFor(options);
+  const session = await createSession(config, options);
+  const manifest = loadManifest(projectDir);
+  const results = [];
+
+  for (const resourceId of ids) {
+    const entry = getEntry(manifest, canonical, resourceId);
+    if (!entry) {
+      throw new WorktreeError('RESOURCE_NOT_CHECKED_OUT', `${canonical} ${resourceId} is not checked out.`);
+    }
+    if (entry.server !== config.server) {
+      throw new WorktreeError('CHECKOUT_SERVER_MISMATCH', 'Checkout belongs to a different DraftGo server.');
+    }
+    if (unresolvedConflict(projectDir, canonical, resourceId)) {
+      throw new WorktreeError(
+        'UNRESOLVED_CONFLICT',
+        `${canonical} ${resourceId} has an unresolved conflict; resolve it before committing.`,
+      );
+    }
+
+    const localPath = absolutePath(projectDir, entry.local_path);
+    const current = await hashFile(localPath);
+    if (current.hash === entry.base_hash) {
+      results.push({ resource_type: canonical, resource_id: resourceId, status: 'unchanged', hash: current.hash });
+      continue;
+    }
+    validateContentFile(localPath, entry.content_type);
+
+    const fresh = await backend.resolveMetadata(config, canonical, resourceId, {
+      ...options,
+      ...session,
+      clientInitialized: true,
+    });
+    assertMetadataIdentity(fresh, canonical, resourceId);
+    const commitMetadata = {
+      ...fresh,
+      content_type: entry.content_type,
+      base_version: entry.base_version,
+      base_revision: entry.base_revision,
+      etag: entry.base_etag,
+    };
+
+    let responsePayload;
+    try {
+      responsePayload = await backend.commit(config, commitMetadata, localPath, current, options);
+    } catch (error) {
+      if (!isVersionConflict(error)) throw error;
+      const conflict = await writeConflict(projectDir, entry, error, config, backend, options, session);
+      throw new WorktreeError(
+        'RESOURCE_VERSION_CONFLICT',
+        `${canonical} ${resourceId} changed remotely; conflict materials were preserved.`,
+        conflict,
+      );
+    }
+
+    let committed = commitVersion(normalizeCommitPayload(responsePayload));
+    if (!committed.hash || (committed.version == null && committed.revision == null)) {
+      const confirmed = await backend.resolveMetadata(config, canonical, resourceId, {
+        ...options,
+        ...session,
+        clientInitialized: true,
+      });
+      assertMetadataIdentity(confirmed, canonical, resourceId);
+      committed = {
+        version: confirmed.base_version,
+        revision: confirmed.base_revision,
+        etag: confirmed.etag,
+        hash: confirmed.content_hash,
+        updated_at: confirmed.updated_at,
+        updated_by: confirmed.updated_by,
+      };
+    }
+    if (committed.hash && committed.hash !== current.hash) {
+      throw new WorktreeError(
+        'HASH_MISMATCH',
+        'DraftGo commit response hash differs from the uploaded raw bytes; manifest was not advanced.',
+        { local_hash: current.hash, remote_hash: committed.hash },
+      );
+    }
+
+    await copyFileAtomic(localPath, absolutePath(projectDir, entry.base_path), { expectedHash: current.hash });
+    entry.base_hash = current.hash;
+    entry.content_size = current.size;
+    entry.base_version = committed.version;
+    entry.base_revision = committed.revision;
+    entry.base_etag = committed.etag;
+    entry.updated_at = committed.updated_at;
+    entry.updated_by = committed.updated_by;
+    entry.committed_at = new Date().toISOString();
+    await saveManifest(projectDir, manifest);
+    results.push({
+      resource_type: canonical,
+      resource_id: resourceId,
+      status: 'committed',
+      hash: current.hash,
+      base_version: entry.base_version,
+      base_revision: entry.base_revision,
+    });
+  }
+  return results;
+}
+
+function diffResource(projectDir, resourceType, resourceId, options = {}) {
+  const entry = getEntry(loadManifest(projectDir), resourceType, resourceId);
+  if (!entry) throw new WorktreeError('RESOURCE_NOT_CHECKED_OUT', `${resourceType} ${resourceId} is not checked out.`);
+  const base = absolutePath(projectDir, entry.base_path);
+  const local = absolutePath(projectDir, entry.local_path);
+  const result = spawnSync('git', [
+    'diff', '--no-index', '--no-color', '--', base, local,
+  ], {
+    cwd: projectDir,
+    encoding: 'utf8',
+    shell: false,
+    maxBuffer: options.maxBuffer || 64 * 1024 * 1024,
+  });
+  if (result.error) throw new WorktreeError('DIFF_UNAVAILABLE', `Unable to run git diff: ${result.error.message}`);
+  if (![0, 1].includes(result.status)) {
+    throw new WorktreeError('DIFF_FAILED', result.stderr || `git diff exited with ${result.status}.`);
+  }
+  return { entry, changed: result.status === 1, output: result.stdout || '' };
+}
+
+function readConflictFile(file) {
+  try {
+    const record = JSON.parse(fs.readFileSync(file, 'utf8'));
+    if (!record || record.schema_version !== CONFLICT_SCHEMA_VERSION) {
+      throw new Error('unsupported schema');
+    }
+    return record;
+  } catch (error) {
+    throw new WorktreeError('INVALID_CONFLICT_MANIFEST', `Invalid conflict manifest ${file}: ${error.message}`);
+  }
+}
+
+function listConflicts(projectDir, options = {}) {
+  const root = path.join(projectDir, '.draftgo', 'conflicts');
+  if (!fs.existsSync(root)) return [];
+  const records = [];
+  const visit = (directory) => {
+    for (const item of fs.readdirSync(directory, { withFileTypes: true })) {
+      const absolute = path.join(directory, item.name);
+      if (item.isDirectory()) visit(absolute);
+      else if (item.isFile() && item.name === 'conflict.json') {
+        const record = readConflictFile(absolute);
+        if (options.all || record.status === 'unresolved') {
+          records.push({ ...record, manifest_path: relativePath(projectDir, absolute) });
+        }
+      }
+    }
+  };
+  visit(root);
+  return records.sort((left, right) => `${left.resource_type}:${left.resource_id}`
+    .localeCompare(`${right.resource_type}:${right.resource_id}`));
+}
+
+function showConflict(projectDir, resourceType, resourceId) {
+  const canonical = canonicalResourceType(resourceType);
+  const match = listConflicts(projectDir, { all: true }).find((record) =>
+    record.resource_type === canonical && String(record.resource_id) === String(resourceId));
+  if (!match) throw new WorktreeError('CONFLICT_NOT_FOUND', `No conflict found for ${canonical} ${resourceId}.`);
+  return match;
+}
+
+async function resolveConflict(projectDir, resourceType, resourceId) {
+  const canonical = canonicalResourceType(resourceType);
+  const manifest = loadManifest(projectDir);
+  const entry = getEntry(manifest, canonical, resourceId);
+  if (!entry) throw new WorktreeError('RESOURCE_NOT_CHECKED_OUT', `${canonical} ${resourceId} is not checked out.`);
+  const conflict = showConflict(projectDir, canonical, resourceId);
+  if (conflict.status !== 'unresolved') {
+    throw new WorktreeError('CONFLICT_ALREADY_RESOLVED', `${canonical} ${resourceId} is already resolved.`);
+  }
+
+  const localPath = absolutePath(projectDir, entry.local_path);
+  validateContentFile(localPath, entry.content_type);
+  const local = await hashFile(localPath);
+  const remotePath = absolutePath(projectDir, conflict.remote_path);
+  const remote = await hashFile(remotePath);
+  if (remote.hash !== conflict.actual_hash) {
+    throw new WorktreeError('HASH_MISMATCH', 'Preserved remote conflict content no longer matches its manifest.');
+  }
+
+  await copyFileAtomic(remotePath, absolutePath(projectDir, entry.base_path), { expectedHash: remote.hash });
+  entry.base_hash = remote.hash;
+  entry.base_version = conflict.actual_base_version;
+  entry.base_revision = conflict.actual_base_revision;
+  entry.base_etag = conflict.actual_etag;
+  entry.updated_at = conflict.updated_at;
+  entry.updated_by = conflict.updated_by;
+  entry.conflict_resolved_at = new Date().toISOString();
+  await saveManifest(projectDir, manifest);
+
+  const manifestFile = absolutePath(projectDir, conflict.manifest_path);
+  const resolved = {
+    ...conflict,
+    status: 'resolved',
+    resolution_local_hash: local.hash,
+    resolved_at: new Date().toISOString(),
+  };
+  delete resolved.manifest_path;
+  await writeJsonAtomic(manifestFile, resolved);
+  return { ...resolved, manifest_path: relativePath(projectDir, manifestFile) };
+}
+
+module.exports = {
+  CONFLICT_SCHEMA_VERSION,
+  worktreePaths,
+  conflictPaths,
+  checkoutResources,
+  commitResources,
+  diffResource,
+  listConflicts,
+  showConflict,
+  resolveConflict,
+};

package/src/worktree/manifest.js

@@ -0,0 +1,75 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const { WorktreeError } = require('./errors');
+const { entryKey } = require('./types');
+const { writeJsonAtomic } = require('./streams');
+
+const MANIFEST_SCHEMA_VERSION = 1;
+
+function manifestPath(projectDir) {
+  return path.join(projectDir, '.draftgo', 'worktree', 'manifest.json');
+}
+
+function emptyManifest() {
+  return { schema_version: MANIFEST_SCHEMA_VERSION, entries: {} };
+}
+
+function loadManifest(projectDir) {
+  const file = manifestPath(projectDir);
+  if (!fs.existsSync(file)) return emptyManifest();
+  let parsed;
+  try {
+    parsed = JSON.parse(fs.readFileSync(file, 'utf8'));
+  } catch (error) {
+    throw new WorktreeError('INVALID_WORKTREE_MANIFEST', `Invalid checkout manifest: ${error.message}`);
+  }
+  if (!parsed || parsed.schema_version !== MANIFEST_SCHEMA_VERSION
+      || !parsed.entries || typeof parsed.entries !== 'object' || Array.isArray(parsed.entries)) {
+    throw new WorktreeError('INVALID_WORKTREE_MANIFEST', 'Unsupported or malformed checkout manifest.');
+  }
+  return parsed;
+}
+
+function getEntry(manifest, resourceType, resourceId) {
+  return manifest.entries[entryKey(resourceType, resourceId)] || null;
+}
+
+function relativePath(projectDir, absolutePath) {
+  const relative = path.relative(path.resolve(projectDir), path.resolve(absolutePath));
+  if (!relative || relative.startsWith('..') || path.isAbsolute(relative)) {
+    throw new WorktreeError('INVALID_WORKTREE_PATH', 'Checkout paths must stay inside the project.');
+  }
+  return relative.replace(/\\/g, '/');
+}
+
+function absolutePath(projectDir, relative) {
+  if (!relative || typeof relative !== 'string' || path.isAbsolute(relative)) {
+    throw new WorktreeError('INVALID_WORKTREE_PATH', 'Manifest path must be project-relative.');
+  }
+  const root = path.resolve(projectDir);
+  const resolved = path.resolve(root, relative);
+  const relation = path.relative(root, resolved);
+  if (!relation || relation.startsWith('..') || path.isAbsolute(relation)) {
+    throw new WorktreeError('INVALID_WORKTREE_PATH', 'Manifest path escapes the project.');
+  }
+  return resolved;
+}
+
+async function saveManifest(projectDir, manifest) {
+  manifest.schema_version = MANIFEST_SCHEMA_VERSION;
+  manifest.updated_at = new Date().toISOString();
+  await writeJsonAtomic(manifestPath(projectDir), manifest);
+}
+
+module.exports = {
+  MANIFEST_SCHEMA_VERSION,
+  manifestPath,
+  emptyManifest,
+  loadManifest,
+  getEntry,
+  relativePath,
+  absolutePath,
+  saveManifest,
+};