@6reduk/workspace-pipeline 0.1.0

package/src/workspace/repository-tree.js

@@ -0,0 +1,57 @@
+import path from 'node:path';
+import { performance } from 'node:perf_hooks';
+import { fail } from '../contracts/parse.js';
+import { contractDigest } from '../contracts/semantic.js';
+import { runRepositoryGit,parseListing } from '../source/git.js';
+import { repositoryBudget } from '../source/repository-budget.js';
+import { absoluteRoot,pathBudget } from './paths.js';
+
+// User repository paths are not package paths: Unicode and large assets allowed.
+// Keep one portable namespace so a Windows checkout cannot alias another entry.
+export function checkRepositoryTreePaths(entries, destination) {
+  destination=absoluteRoot(destination);
+  if (entries.length>200000) fail('repository-tree.entries');
+  const names=new Map();let total=0;
+  for (const entry of entries) {
+    if (entry.type!=='blob' || !['100644','100755'].includes(entry.mode)) fail('repository-tree.entry-type');
+    if (!Number.isSafeInteger(entry.size) || entry.size<0) fail('repository-tree.size');
+    total+=entry.size;if(total>100*1024**3)fail('repository-tree.bytes');
+    if (typeof entry.path!=='string' || /[\\\u0000-\u001f\u007f<>:"|?*]/u.test(entry.path)) fail('repository-tree.path');
+    const parts=entry.path.split('/');
+    if(parts.length>128)fail('repository-tree.depth');
+    for(let i=0;i<parts.length;i++) {
+      const part=parts[i];
+      if (!part || part==='.' || part==='..' || /[. ]$/.test(part) ||
+        /^\.git$/i.test(part) || /~[0-9]/.test(part) ||
+        /^(?:con|prn|aux|nul|com[1-9¹²³]|lpt[1-9¹²³])(?:\.|$)/i.test(part)) fail('repository-tree.path');
+      const spelling=parts.slice(0,i+1).join('/'),key=spelling.normalize('NFC').toLowerCase();
+      const kind=i===parts.length-1?'file':'directory',previous=names.get(key);
+      if(previous && (previous.spelling!==spelling || previous.kind!==kind || kind==='file'))fail('repository-tree.collision');
+      names.set(key,{spelling,kind});
+    }
+    pathBudget(path.join(destination,...parts));
+  }
+  return total;
+}
+
+// Read committed objects, never checkout/smudge/filter. Connectivity and exact
+// source/staging inventory bindings are supplied by the surrounding preview.
+export async function inspectRepositoryTree(repo, commit, destination, requestedBudget = {}) {
+  if (!/^(?:[a-f0-9]{40}|[a-f0-9]{64})$/.test(commit)) fail('repository-tree.commit');
+  const budget=repositoryBudget(requestedBudget);
+  const options={...budget,deadline:performance.now()+budget.acquisitionMs};
+  const entries=parseListing((await runRepositoryGit(repo,['ls-tree','-r','-l','-z','--full-tree',commit],
+    {...options,outputLimit:256*1024*1024})).bytes);
+  const totalBytes=checkRepositoryTreePaths(entries,destination);
+  const seen=new Set();
+  for(const entry of entries) {
+    // Valid LFS pointers are small. No external LFS client/download is invoked.
+    if(entry.size>1024 || seen.has(entry.oid))continue;
+    seen.add(entry.oid);
+    const bytes=(await runRepositoryGit(repo,['cat-file','blob',entry.oid],{...options,outputLimit:1024})).bytes;
+    if(bytes.length!==entry.size)fail('repository-tree.blob-size');
+    if(bytes.toString('utf8').startsWith('version https://git-lfs.github.com/spec/v1'))fail('repository-tree.lfs');
+  }
+  return {commit,entries,totalBytes,digest:contractDigest(entries),
+    checkout:'not-performed',filters:'not-run',executionAuthorized:false};
+}

package/src/workspace/reserved.js

@@ -0,0 +1,11 @@
+import { fail } from '../contracts/parse.js';
+
+export const RESERVED = Object.freeze(['.pipeline', '.codex', '.claude', '.kimi-code',
+  '.grok', '.agents', '.git', '.mcp.json', 'AGENTS.md', 'CLAUDE.md', 'CLAUDE.local.md', 'GROK.md', 'workspace.yaml']);
+export function assertUnreserved(relative) {
+  if (RESERVED.some(name => name.toLowerCase() === relative.split('/')[0].toLowerCase())) fail('layout.reserved');
+}
+export function overlaps(a, b) {
+  a = a.toLowerCase(); b = b.toLowerCase();
+  return a === b || a.startsWith(b + '/') || b.startsWith(a + '/');
+}

package/src/workspace/resolve.js

@@ -0,0 +1,53 @@
+import path from 'node:path';
+import { fail } from '../contracts/parse.js';
+import { portablePath } from '../contracts/semantic.js';
+import { selectProfile } from './profiles.js';
+import { assertUnreserved, overlaps } from './reserved.js';
+import { absoluteRoot, pathBudget, resolveChild, inspectDirectory } from './paths.js';
+
+// Pure path map. missing/existing Git repos and provider discovery are not certified.
+export function planLayout(pipeline, workspace, wrapper, { adapters, managedPaths = [] } = {}) {
+  const selected = selectProfile(pipeline, workspace, adapters);
+  const root = absoluteRoot(wrapper); pathBudget(root);
+  const { layout } = selected, repositories = {}, projectRoots = {}, warnings = [];
+  for (const target of managedPaths) portablePath(target);
+  const entries = Object.entries(layout.repositories).sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0);
+  const spellings = new Map();
+  const registerSpelling = relative => {
+    const parts = relative.split('/');
+    for (let i = 1; i <= parts.length; i++) {
+      const prefix = parts.slice(0, i).join('/'), key = prefix.toLowerCase();
+      if (spellings.has(key) && spellings.get(key) !== prefix) fail('layout.case-alias');
+      spellings.set(key, prefix);
+    }
+  };
+  for (const target of managedPaths) registerSpelling(target);
+  for (const [id, repo] of entries) {
+    assertUnreserved(repo.path);
+    registerSpelling(repo.path);
+    if (Object.values(repositories).some(r => overlaps(r.relative, repo.path)) ||
+      managedPaths.some(target => overlaps(target, repo.path))) fail('layout.overlap');
+    repositories[id] = { relative: repo.path, path: resolveChild(root, repo.path), role: repo.role };
+    if (repo.role === 'documentation' && layout.documentation.repository !== id)
+      warnings.push({ code: 'layout.unused-documentation-role', repository: id });
+  }
+  const reference = ref => {
+    const relative = path.posix.join(layout.repositories[ref.repository].path, ref.path);
+    portablePath(relative);
+    registerSpelling(relative);
+    return { repository: ref.repository, relative, path: resolveChild(root, relative) };
+  };
+  const documentation = reference(layout.documentation);
+  for (const id of Object.keys(layout.projectRoots ?? {}).sort()) projectRoots[id] = reference(layout.projectRoots[id]);
+  return { ...selected, wrapper: root, repositories, documentation, projectRoots, warnings, filesystem: 'not-inspected', runtime: 'not-run' };
+}
+export async function resolveLayout(pipeline, workspace, wrapper, options) {
+  const result = planLayout(pipeline, workspace, wrapper, options);
+  // No mkdir/clone/move even for a not-yet-created wrapper. Existing ancestors
+  // are inspected; missing paths remain planned paths, never readiness PASS.
+  const observations = {};
+  const targets = [result.wrapper, ...Object.values(result.repositories).map(r => r.path),
+    result.documentation.path, ...Object.values(result.projectRoots).map(r => r.path)];
+  for (const target of new Set(targets)) observations[target] = await inspectDirectory(target);
+  return { ...result, filesystem: 'inspected', observations };
+}