@tiinex/app 0.1.1

package/src/workspaces/workspace.importConflicts.js

@@ -0,0 +1,200 @@
+export const IMPORT_CONFLICT_SCHEMA_ID = 'tiinex.workspace.import.conflict.v1';
+export const ImportConflictResolution = Object.freeze({
+  SIBLING: 'sibling',
+  REPLACE: 'replace',
+  CANCEL: 'cancel'
+});
+
+export function detectLocalImportConflicts(workspace = {}, adapterResult = {}) {
+  const incoming = importMaterialEntries(adapterResult);
+  if (!incoming.length) return [];
+  const existing = workspaceMaterialEntries(workspace);
+  const existingByPath = new Map(existing.map((entry) => [canonicalPath(entry.path), entry]));
+  const localTraceSlots = new Map();
+  for (const entry of existing) {
+    if (!isLocalMaterial(entry.material)) continue;
+    const slot = traceDimensionSlot(entry.path);
+    if (slot) localTraceSlots.set(slot, entry);
+  }
+
+  const conflicts = [];
+  for (const entry of incoming) {
+    const path = canonicalPath(entry.path);
+    if (!path) continue;
+    if (isTracePath(path)) {
+      const slot = traceDimensionSlot(path);
+      const existingSlot = slot ? localTraceSlots.get(slot) : null;
+      if (existingSlot) {
+        conflicts.push(conflict('trace-slot', entry, existingSlot));
+        continue;
+      }
+    }
+    const existingPath = existingByPath.get(path);
+    if (existingPath && isLocalMaterial(existingPath.material)) conflicts.push(conflict('path', entry, existingPath));
+  }
+  return dedupeConflicts(conflicts);
+}
+
+export function resolveLocalImportConflicts(workspace = {}, adapterResult = {}, resolution = '') {
+  const mode = String(resolution || '').trim().toLowerCase();
+  const conflicts = detectLocalImportConflicts(workspace, adapterResult);
+  if (!conflicts.length) return { ok: true, resolution: 'none', conflicts: [], adapterResult };
+  if (mode === ImportConflictResolution.CANCEL) return { ok: false, cancelled: true, resolution: mode, conflicts, adapterResult: null };
+  if (mode === ImportConflictResolution.REPLACE) return { ok: true, resolution: mode, conflicts, adapterResult };
+  if (mode !== ImportConflictResolution.SIBLING) return { ok: false, requiresResolution: true, resolution: '', conflicts, adapterResult: null };
+
+  const pathMap = buildSiblingPathMap(workspace, adapterResult, conflicts);
+  return {
+    ok: true,
+    resolution: mode,
+    conflicts,
+    pathMap,
+    adapterResult: remapAdapterResultPaths(adapterResult, pathMap)
+  };
+}
+
+export function importConflictSummary(conflicts = []) {
+  const trace = conflicts.filter((item) => item.type === 'trace-slot').length;
+  const path = conflicts.filter((item) => item.type === 'path').length;
+  const parts = [];
+  if (trace) parts.push(`${trace} lineage slot conflict${trace === 1 ? '' : 's'}`);
+  if (path) parts.push(`${path} file path conflict${path === 1 ? '' : 's'}`);
+  return parts.join(' · ') || 'Import conflicts';
+}
+
+function importMaterialEntries(adapterResult = {}) {
+  return [
+    ...(adapterResult.records || []).map((material) => entryFor(material, 'record')),
+    ...(adapterResult.workspaceEntries || []).map((material) => entryFor(material, 'workspace')),
+    ...(adapterResult.assets || []).map((material) => entryFor(material, 'asset'))
+  ].filter((entry) => entry.path);
+}
+
+function workspaceMaterialEntries(workspace = {}) {
+  const out = [
+    ...(workspace.records || []).map((material) => entryFor(material, 'record')),
+    ...(workspace.assets || []).map((material) => entryFor(material, 'asset'))
+  ];
+  const workspacePath = workspace.workspaceImport?.path || '';
+  if (workspacePath) out.push(entryFor({ path: workspacePath, source: workspace.source || { adapterId: 'local', kind: 'local-session' } }, 'workspace-root'));
+  return out.filter((entry) => entry.path);
+}
+
+function entryFor(material = {}, kind = '') {
+  return { path: canonicalPath(material.path || material.name || ''), kind, material };
+}
+
+function conflict(type, incoming, existing) {
+  return Object.freeze({
+    schema: IMPORT_CONFLICT_SCHEMA_ID,
+    type,
+    incoming: incoming.path,
+    existing: existing.path,
+    materialKind: incoming.kind,
+    slot: type === 'trace-slot' ? traceDimensionSlot(incoming.path) : ''
+  });
+}
+
+function dedupeConflicts(conflicts = []) {
+  const seen = new Set();
+  return conflicts.filter((item) => {
+    const key = `${item.type}:${item.incoming}:${item.existing}`;
+    if (seen.has(key)) return false;
+    seen.add(key);
+    return true;
+  });
+}
+
+function buildSiblingPathMap(workspace = {}, adapterResult = {}, conflicts = []) {
+  const occupied = new Set(workspaceMaterialEntries(workspace).map((entry) => canonicalPath(entry.path)).filter(Boolean));
+  const map = new Map();
+  const incoming = importMaterialEntries(adapterResult);
+  const traceConflicts = conflicts.filter((item) => item.type === 'trace-slot');
+
+  for (const conflictItem of traceConflicts) {
+    const oldDim = traceDimensionFromPath(conflictItem.incoming);
+    const newDim = nextSiblingDimension(occupied, conflictItem.existing || conflictItem.incoming);
+    if (!oldDim || !newDim || oldDim === newDim) continue;
+    const incomingDir = dirname(conflictItem.incoming);
+    for (const entry of incoming) {
+      if (dirname(entry.path) !== incomingDir || !fileName(entry.path).startsWith(oldDim)) continue;
+      const renamed = canonicalPath(joinPath(incomingDir, newDim + fileName(entry.path).slice(oldDim.length)));
+      map.set(entry.path, renamed);
+      occupied.add(renamed);
+    }
+  }
+
+  for (const entry of incoming) {
+    const current = map.get(entry.path) || entry.path;
+    if (!occupied.has(current)) {
+      occupied.add(current);
+      continue;
+    }
+    if (isTracePath(current)) continue;
+    const renamed = nextPathSibling(occupied, current);
+    map.set(entry.path, renamed);
+    occupied.add(renamed);
+  }
+  return map;
+}
+
+function remapAdapterResultPaths(adapterResult = {}, pathMap = new Map()) {
+  const remap = (material = {}) => {
+    const oldPath = canonicalPath(material.path || material.name || '');
+    const path = pathMap.get(oldPath) || oldPath;
+    if (!path || path === oldPath) return Object.assign({}, material);
+    return Object.assign({}, material, { path, name: fileName(path), importConflictOriginalPath: oldPath, importConflictResolution: 'sibling' });
+  };
+  return Object.assign({}, adapterResult, {
+    records: (adapterResult.records || []).map(remap),
+    workspaceEntries: (adapterResult.workspaceEntries || []).map(remap),
+    assets: (adapterResult.assets || []).map(remap),
+    diagnostics: Object.assign({}, adapterResult.diagnostics || {}, { importConflictResolution: 'sibling', importSiblingRemapCount: pathMap.size })
+  });
+}
+
+function isLocalMaterial(material = {}) {
+  const source = material.source || {};
+  const mode = String(material.sourceMode || '').toLowerCase();
+  return source.adapterId === 'local' || source.kind === 'local-session' || source.kind === 'local' || mode.startsWith('local-') || mode.includes('archive') || mode.includes('manual') || mode.includes('drop') || mode.includes('roundtrip');
+}
+
+function traceDimensionFromPath(path = '') {
+  const match = fileName(path).match(/^(\d{3}(?:-\d+)*)/u);
+  return match ? match[1] : '';
+}
+
+function traceDimensionSlot(path = '') {
+  const dim = traceDimensionFromPath(path);
+  return dim ? `${dirname(path)}::${dim}` : '';
+}
+
+function nextSiblingDimension(occupiedPaths = new Set(), conflictingPath = '') {
+  const dim = traceDimensionFromPath(conflictingPath);
+  if (!dim) return '';
+  const parts = dim.split('-').filter(Boolean);
+  const current = Number(parts.pop() || 0);
+  const parent = parts.join('-');
+  let next = Math.max(current + 1, 1);
+  const dir = dirname(conflictingPath);
+  while ([...occupiedPaths].some((path) => dirname(path) === dir && traceDimensionFromPath(path) === formatDimension(parent, next))) next += 1;
+  return formatDimension(parent, next);
+}
+
+function formatDimension(parent, index) { return parent ? `${parent}-${index}` : String(index).padStart(3, '0'); }
+function nextPathSibling(occupied, path) {
+  const dir = dirname(path);
+  const name = fileName(path);
+  const dot = name.lastIndexOf('.');
+  const stem = dot >= 0 ? name.slice(0, dot) : name;
+  const ext = dot >= 0 ? name.slice(dot) : '';
+  let n = 2;
+  let candidate = canonicalPath(joinPath(dir, `${stem}-sibling-${n}${ext}`));
+  while (occupied.has(candidate)) { n += 1; candidate = canonicalPath(joinPath(dir, `${stem}-sibling-${n}${ext}`)); }
+  return candidate;
+}
+function isTracePath(path = '') { return /\.trace\.md$/iu.test(path); }
+function dirname(path = '') { const parts = canonicalPath(path).split('/'); parts.pop(); return parts.join('/'); }
+function fileName(path = '') { return canonicalPath(path).split('/').filter(Boolean).pop() || ''; }
+function joinPath(dir = '', name = '') { return [dir, name].filter(Boolean).join('/'); }
+function canonicalPath(value = '') { return String(value || '').replace(/\\/g, '/').replace(/^\/+/, '').replace(/\/+/g, '/').trim(); }

package/src/workspaces/workspace.importLifecycle.case.mjs

@@ -0,0 +1,103 @@
+import assert from 'node:assert/strict';
+import '../sources/source.identity.js';
+import './workspace.route.js';
+import './workspace.persistenceRouteCache.js';
+import './workspace.persistenceClear.js';
+import './workspace.persistence.js';
+import './workspace.lifecycle.js';
+import { createRecordFromMarkdown } from '@tiinex/core/artifacts/artifact.record.js';
+import { applyLocalAdapterResultToWorkspace } from './workspace.import.js';
+import { summarizeWorkspaceMaterial } from './workspace.summary.js';
+
+const lifecycle = globalThis.TiinexWorkspaceLifecycle;
+const persistence = globalThis.TiinexWorkspacePersistence;
+const clock = () => '2026-08-11T00:00:00.000Z';
+
+function memoryEnv() {
+  const storageMap = new Map();
+  const location = { pathname: '/index.html', search: '', hash: '' };
+  const history = {
+    replaceState: (_state, _title, url) => { location.hash = url.includes('#') ? `#${url.split('#').pop()}` : ''; },
+    pushState: (_state, _title, url) => { location.hash = url.includes('#') ? `#${url.split('#').pop()}` : ''; }
+  };
+  const storage = {
+    getItem: (key) => storageMap.get(key) || null,
+    setItem: (key, value) => storageMap.set(key, String(value)),
+    removeItem: (key) => storageMap.delete(key)
+  };
+  return { storage, location, history, storageMap };
+}
+
+let state = lifecycle.makeEmptyAppState();
+const created = lifecycle.createWorkspace(state, { name: 'M1 Lifecycle' }, { clock });
+state = created.state;
+const workspaceId = created.workspace.id;
+const registered = lifecycle.addWorkspaceSource(state, workspaceId, { label: 'Tiinex/docs', repository: 'Tiinex/docs', rootPath: '.topics', repoDiscovery: true });
+state = registered.state;
+const source = registered.source;
+
+const startPath = '.topics/start.md';
+const startMarkdown = '# Start\n\nSame content';
+const docsPath = '.topics/docs.workspace.md';
+const docsMarkdown = '# Documentation\n\n- Current Schema: tiinex.workspace.v1\n\n## Workspace Entrypoints\n\n- Source Kind: github-tree\n- Repository: Tiinex/docs\n- Root Path: .topics\n';
+
+const sourceLoaded = lifecycle.addWorkspaceSourceRecords(state, workspaceId, source.id, [
+  { title: 'Start', path: startPath, markdown: startMarkdown, sourceMode: 'source-backed', integrity: { entries: [{ towards: 'self', value: 'sha-start' }] } },
+  { title: 'Documentation', path: docsPath, kind: 'tiinex.workspace.v1', schemaId: 'tiinex.workspace.v1', markdown: docsMarkdown, sourceMode: 'source-backed', integrity: { entries: [{ towards: 'self', value: 'sha-docs' }] } }
+], { clock });
+assert.equal(sourceLoaded.ok, true, sourceLoaded.error);
+state = sourceLoaded.state;
+assert.equal(Object.prototype.hasOwnProperty.call(sourceLoaded.workspace, 'workspaceMergeCandidates'), false, 'source workspace artifacts stay on the canonical record spine');
+
+const imported = applyLocalAdapterResultToWorkspace(lifecycle, state, workspaceId, {
+  schema: 'tiinex.adapter.result.v1', adapterId: 'archive', sourceId: 'local',
+  records: [createRecordFromMarkdown(startMarkdown, { title: 'Start local duplicate', path: startPath, sourceMode: 'archive-local' })],
+  assets: [{ path: 'assets/evidence.png', name: 'evidence.png', type: 'image/png', size: 12, dataUrl: 'data:image/png;base64,ZmFrZQ==', sourceMode: 'archive-local-asset', source: { id: source.id, adapterId: 'github', kind: 'github-tree' }, publicAvailability: 'public' }],
+  workspaceEntries: [{ title: 'Documentation local duplicate', path: docsPath, markdown: docsMarkdown, sourceMode: 'zip' }],
+  warnings: [], errors: [], diagnostics: { suggestedWorkspaceName: 'Ignored' }
+}, { clock });
+assert.equal(imported.ok, true, imported.summary?.message);
+state = imported.state;
+
+const reconciled = lifecycle.activeWorkspace(state);
+assert.equal(reconciled.records.length, 2, 'verified source equivalents stay canonical with redundant local payload pruned');
+assert.equal(Object.prototype.hasOwnProperty.call(reconciled, 'workspaceMergeCandidates'), false, 'workspace artifact reconciliation does not create legacy candidate runtime shape');
+assert.equal(reconciled.records.filter((record) => record.source?.id === source.id).length, 2);
+assert.equal(reconciled.records.some((record) => record.materialReconciliation?.localSnapshot), false, 'new reconciliation never hides exact local duplicates as resurrection snapshots');
+assert.equal(reconciled.assets.length, 1, 'independent local asset remains available');
+assert.equal(reconciled.assets[0].source.adapterId, 'local', 'local asset cannot carry fake GitHub source');
+assert.equal(reconciled.assets[0].publicAvailability, 'not-public', 'local asset availability is not public truth');
+const summary = summarizeWorkspaceMaterial(reconciled);
+assert.equal(summary.counts.localAssets, 1);
+assert.equal(summary.counts.reconciledLocalRecords, 0, 'snapshot counts are zero for new canonical reconciliation');
+assert.equal('reconciledLocalWorkspaceCandidates' in summary.counts, false, 'canonical summary exposes no legacy candidate reconciliation count');
+assert.equal(summary.boundaryReadability.mixed, true, 'source records plus independent local asset remain an explicit mixed boundary');
+
+const env = memoryEnv();
+persistence.writeState(state, { storage: env.storage, location: env.location, history: env.history, mode: 'push' });
+assert(env.storageMap.has(persistence.STORAGE_KEY), 'route/source shell cache is separate');
+assert(env.storageMap.has(persistence.LOCAL_DELTA_KEY), 'durable local delta store is separate');
+const restored = persistence.readInitialState({ storage: env.storage, location: env.location });
+assert(restored, 'explicit route restore merges route/source shell with local deltas');
+const restoredWorkspace = restored.workspaces.find((workspace) => workspace.id === workspaceId);
+assert.equal(restoredWorkspace.records.length, 2, 'source record shells restore without local duplicate resurrection');
+assert(restoredWorkspace.records.every((record) => !record.markdown), 'source-backed Markdown is not localStorage authority');
+assert.equal(restoredWorkspace.assets.length, 1, 'durable local asset delta rejoins the matching workspace');
+assert.equal(restoredWorkspace.assets[0].publicAvailability, 'not-public');
+
+const sourceClosedFirst = lifecycle.closeWorkspaceSource(restored, workspaceId, source.id);
+assert.equal(sourceClosedFirst.ok, true);
+assert.equal(sourceClosedFirst.workspace.records.length, 0, 'closing source does not resurrect previously deduplicated local copies');
+assert.equal(Object.prototype.hasOwnProperty.call(sourceClosedFirst.workspace, 'workspaceMergeCandidates'), false, 'source-close does not recreate legacy candidate runtime shape');
+assert.equal(sourceClosedFirst.workspace.assets.length, 1, 'independent local asset survives source close');
+
+const localCleared = lifecycle.closeWorkspaceSource(restored, workspaceId, 'local');
+assert.equal(localCleared.ok, true);
+assert.equal(localCleared.workspace.records.length, 2, 'clear local leaves source-backed record shells intact');
+assert.equal(localCleared.workspace.assets.length, 0, 'clear local removes local asset availability');
+const sourceClosedAfterClear = lifecycle.closeWorkspaceSource(localCleared.state, workspaceId, source.id);
+assert.equal(sourceClosedAfterClear.ok, true);
+assert.equal(sourceClosedAfterClear.workspace.records.length, 0, 'source close after local clear has nothing local to resurrect');
+assert.equal(sourceClosedAfterClear.workspace.assets.length, 0);
+
+console.log('✓ workspace import lifecycle tests passed');