draftgo-cli 3.0.48 → 3.0.49

package/src/worktree/status.js

@@ -0,0 +1,122 @@
+'use strict';
+
+const fs = require('fs');
+const { loadProjectConfig } = require('../projectConfig');
+const { DraftGoMcpClient } = require('../mcp/client');
+const backendDefaults = require('./backend');
+const { loadManifest, absolutePath } = require('./manifest');
+const { hashFile } = require('./streams');
+
+function versionValue(source) {
+  if (!source) return null;
+  if (source.base_version != null) return source.base_version;
+  if (source.base_revision != null) return source.base_revision;
+  return null;
+}
+
+function sameVersion(entry, remote) {
+  const local = versionValue(entry);
+  const current = versionValue(remote);
+  if (local == null || current == null) return true;
+  return String(local) === String(current);
+}
+
+async function optionalHash(projectDir, relative) {
+  if (!relative) return null;
+  const file = absolutePath(projectDir, relative);
+  return fs.existsSync(file) ? (await hashFile(file)).hash : null;
+}
+
+function classify(entry, localHash, baseHash, remote) {
+  const manifestHash = entry.base_hash;
+  const remoteHash = remote && remote.content_hash || null;
+  const baseMatchesManifest = baseHash === manifestHash;
+  const localMatchesManifest = localHash === manifestHash;
+  const localMatchesRemote = Boolean(localHash && remoteHash && localHash === remoteHash);
+  const remoteMatchesManifest = Boolean(remoteHash && remoteHash === manifestHash);
+  const versionMatches = remote ? sameVersion(entry, remote) : null;
+
+  let state;
+  let recommendation = null;
+  if (!localHash) {
+    state = 'local_missing';
+    recommendation = `draftgo checkout ${entry.resource_type} ${entry.resource_id} --force`;
+  } else if (!baseHash) {
+    state = 'base_missing';
+    recommendation = `draftgo checkout ${entry.resource_type} ${entry.resource_id} --force`;
+  } else if (!remote) {
+    state = baseMatchesManifest
+      ? (localMatchesManifest ? 'clean_local' : 'local_modified')
+      : 'local_metadata_corrupt';
+  } else if (localMatchesRemote && (!remoteMatchesManifest || !versionMatches || !baseMatchesManifest)) {
+    state = remoteMatchesManifest ? 'metadata_stale' : 'committed_unrecorded';
+    recommendation = `draftgo reconcile ${entry.resource_type} ${entry.resource_id}`;
+  } else if (!baseMatchesManifest) {
+    state = 'local_metadata_corrupt';
+    recommendation = `draftgo checkout ${entry.resource_type} ${entry.resource_id} --force`;
+  } else if (remoteMatchesManifest && versionMatches) {
+    state = localMatchesManifest ? 'clean' : 'local_modified';
+  } else if (localMatchesManifest) {
+    state = 'remote_changed';
+    recommendation = `draftgo checkout ${entry.resource_type} ${entry.resource_id}`;
+  } else {
+    state = 'diverged';
+    recommendation = `draftgo commit ${entry.resource_type} ${entry.resource_id}`;
+  }
+
+  return {
+    state,
+    local_hash: localHash,
+    base_file_hash: baseHash,
+    manifest_hash: manifestHash,
+    remote_hash: remoteHash,
+    manifest_version: versionValue(entry),
+    remote_version: versionValue(remote),
+    version_matches: versionMatches,
+    local_matches_remote: localMatchesRemote,
+    recommendation,
+  };
+}
+
+async function inspectEntry(projectDir, entry, remote = null) {
+  const [localHash, baseHash] = await Promise.all([
+    optionalHash(projectDir, entry.local_path),
+    optionalHash(projectDir, entry.base_path),
+  ]);
+  return { ...entry, ...classify(entry, localHash, baseHash, remote) };
+}
+
+async function openMetadataSession(config, options = {}) {
+  if (options.client && options.tools) return { client: options.client, tools: options.tools };
+  const client = options.client || new DraftGoMcpClient(config);
+  await client.initialize(options);
+  const tools = options.tools || await client.listAllTools(options);
+  return { client, tools };
+}
+
+async function inspectRemoteCheckouts(projectDir, options = {}) {
+  const config = options.config || loadProjectConfig(projectDir);
+  const manifest = options.manifest || loadManifest(projectDir);
+  const backend = { ...backendDefaults, ...(options.backend || {}) };
+  const session = options.backend && typeof options.backend.resolveMetadata === 'function'
+    ? { client: options.client || {}, tools: options.tools || [] }
+    : await openMetadataSession(config, options);
+  const entries = Object.values(manifest.entries);
+  return Promise.all(entries.map(async (entry) => {
+    const remote = await backend.resolveMetadata(config, entry.resource_type, entry.resource_id, {
+      ...options,
+      ...session,
+      clientInitialized: true,
+    });
+    return inspectEntry(projectDir, entry, remote);
+  }));
+}
+
+module.exports = {
+  versionValue,
+  sameVersion,
+  classify,
+  inspectEntry,
+  openMetadataSession,
+  inspectRemoteCheckouts,
+};