changeledger 0.3.0 → 0.5.0

package/src/registry.mjs

@@ -7,6 +7,7 @@ import fs from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
 import { withFileLock, writeFileAtomic } from './atomic-write.mjs';
+import { loadConfig } from './config.mjs';
 
 export function registryDir() {
   return path.join(process.env.CHANGELEDGER_HOME || os.homedir(), '.changeledger');
@@ -42,7 +43,18 @@ export function register({ id, name, path: repoPath }) {
 }
 
 export function listProjects() {
-  return Object.entries(readRegistry()).map(([id, v]) => ({ id, name: v.name, path: v.path }));
+  return Object.entries(readRegistry()).map(([id, value]) => {
+    let name = value.name;
+    try {
+      const config = loadConfig(path.join(value.path, '.changeledger'));
+      if (String(config.project_id) === id && typeof config.project_name === 'string') {
+        name = config.project_name;
+      }
+    } catch {
+      // Missing projects keep their last registered display name.
+    }
+    return { id, name, path: value.path };
+  });
 }
 
 export function remove(id) {
@@ -53,3 +65,14 @@ export function remove(id) {
     writeRegistry(reg);
   });
 }
+
+export function update(id, values) {
+  fs.mkdirSync(registryDir(), { recursive: true });
+  return withFileLock(registryPath(), () => {
+    const reg = readRegistry();
+    if (!reg[id]) throw new Error(`no registered project "${id}"`);
+    reg[id] = { ...reg[id], ...values };
+    writeRegistry(reg);
+    return reg[id];
+  });
+}

package/src/repo.mjs

@@ -47,6 +47,13 @@ export function loadRepo(start = process.cwd()) {
   }
   const repoRoot = path.dirname(changeledgerDir);
   const config = loadConfig(changeledgerDir);
+  return loadRepoWithConfig(repoRoot, changeledgerDir, config);
+}
+
+// Loads repository content using an already parsed candidate config. The viewer
+// uses this before replacing config.yml so changes to configured directories are
+// validated against the content they would actually expose after the save.
+export function loadRepoWithConfig(repoRoot, changeledgerDir, config) {
   const changesDir = resolveRepoPath(repoRoot, config.changes_dir, 'changes_dir');
 
   const changes = [];

package/src/viewer/domain.mjs

@@ -1,11 +1,15 @@
+import crypto from 'node:crypto';
 import fs from 'node:fs';
 import path from 'node:path';
+import { mutateFileAtomic } from '../atomic-write.mjs';
+import { checkRepo } from '../check.mjs';
 import { status as applyStatusCmd, validation as applyValidation } from '../commands/agent.mjs';
-import { findChangeledgerDir, loadConfig } from '../config.mjs';
+import { findChangeledgerDir, loadConfig, resolveRepoPath, resolveSpecsDir } from '../config.mjs';
 import { computeMetrics } from '../metrics.mjs';
 import { nowUtc } from '../paths.mjs';
-import { listProjects } from '../registry.mjs';
-import { loadRepo } from '../repo.mjs';
+import { listProjects, remove, update } from '../registry.mjs';
+import { loadRepo, loadRepoWithConfig } from '../repo.mjs';
+import { parseYaml } from '../yaml.mjs';
 
 // Serializes a loaded repo into the flat shape the UI consumes.
 export function serialize(repo) {
@@ -131,3 +135,132 @@ export function changeStatus(projects, { project, id, status, reason }) {
     return { code: 400, body: { error: e.message } };
   }
 }
+
+const revision = (text) => crypto.createHash('sha256').update(text).digest('hex');
+
+function projectFor(projects, id) {
+  const project = projects.find((item) => item.id === id);
+  if (!project) return { code: 404, body: { error: `no project "${id}"` } };
+  if (!project.alive) return { code: 410, body: { error: 'project path is gone' } };
+  return { project };
+}
+
+export function readProjectConfig(projects, id) {
+  const found = projectFor(projects, id);
+  if (!found.project) return found;
+  const file = path.join(found.project.path, '.changeledger', 'config.yml');
+  const content = fs.readFileSync(file, 'utf8');
+  return { code: 200, body: { content, revision: revision(content) } };
+}
+
+export function saveProjectConfig(projects, payload, { mutateConfig = mutateFileAtomic } = {}) {
+  const found = projectFor(projects, payload.project);
+  if (!found.project) return found;
+  if (typeof payload.content !== 'string' || typeof payload.revision !== 'string') {
+    return { code: 400, body: { error: 'content and revision are required' } };
+  }
+
+  let candidate;
+  try {
+    candidate = parseYaml(payload.content);
+  } catch (error) {
+    return { code: 400, body: { error: error.message } };
+  }
+  if (String(candidate.project_id ?? '') !== String(found.project.id)) {
+    return { code: 400, body: { error: 'project_id cannot be changed from the viewer' } };
+  }
+
+  let repo;
+  try {
+    repo = loadRepo(found.project.path);
+  } catch {
+    return { code: 400, body: { error: 'unable to load the current project configuration' } };
+  }
+  try {
+    resolveRepoPath(repo.repoRoot, candidate.changes_dir, 'changes_dir');
+    resolveSpecsDir(repo.repoRoot, candidate);
+  } catch (error) {
+    return { code: 400, body: { error: error.message } };
+  }
+  let candidateRepo;
+  try {
+    candidateRepo = loadRepoWithConfig(repo.repoRoot, repo.changeledgerDir, candidate);
+  } catch {
+    return { code: 400, body: { error: 'candidate configuration cannot load the repository' } };
+  }
+  let errors;
+  try {
+    ({ errors } = checkRepo(candidateRepo));
+  } catch {
+    return {
+      code: 400,
+      body: { error: 'candidate configuration violates the ChangeLedger contract' },
+    };
+  }
+  if (errors.length) return { code: 400, body: { error: errors[0].message } };
+
+  const file = path.join(repo.changeledgerDir, 'config.yml');
+  const projectName =
+    typeof candidate.project_name === 'string' && candidate.project_name.trim()
+      ? candidate.project_name
+      : found.project.name;
+  try {
+    mutateConfig(file, (before) => {
+      if (revision(before) !== payload.revision) {
+        throw new Error('configuration changed on disk; reload before saving');
+      }
+      return payload.content;
+    });
+  } catch (error) {
+    if (error.message === 'configuration changed on disk; reload before saving') {
+      return { code: 409, body: { error: error.message } };
+    }
+    return { code: 400, body: { error: 'unable to save project configuration' } };
+  }
+  return {
+    code: 200,
+    body: { ok: true, name: projectName, revision: revision(payload.content) },
+  };
+}
+
+export function repairProjectPath(projects, payload, { localOnly = false } = {}) {
+  if (localOnly)
+    return { code: 403, body: { error: 'registry management is unavailable in local mode' } };
+  const project = projects.find((item) => item.id === payload.project);
+  if (!project) return { code: 404, body: { error: `no project "${payload.project}"` } };
+  if (typeof payload.path !== 'string' || !path.isAbsolute(payload.path)) {
+    return { code: 400, body: { error: 'project path must be absolute' } };
+  }
+  const root = path.resolve(payload.path);
+  let config;
+  try {
+    config = loadConfig(path.join(root, '.changeledger'));
+  } catch {
+    return { code: 400, body: { error: 'project path is not a ChangeLedger repository' } };
+  }
+  if (String(config.project_id ?? '') !== String(project.id)) {
+    return { code: 400, body: { error: 'project path belongs to a different project_id' } };
+  }
+  try {
+    update(project.id, { name: config.project_name ?? project.name, path: root });
+  } catch {
+    return { code: 400, body: { error: 'unable to update project registry' } };
+  }
+  return { code: 200, body: { ok: true } };
+}
+
+export function unregisterProject(projects, payload, { localOnly = false } = {}) {
+  if (localOnly)
+    return { code: 403, body: { error: 'registry management is unavailable in local mode' } };
+  const project = projects.find((item) => item.id === payload.project);
+  if (!project) return { code: 404, body: { error: `no project "${payload.project}"` } };
+  if (payload.confirm !== project.name) {
+    return { code: 400, body: { error: `type "${project.name}" to confirm` } };
+  }
+  try {
+    remove(project.id);
+  } catch {
+    return { code: 400, body: { error: 'unable to update project registry' } };
+  }
+  return { code: 200, body: { ok: true } };
+}

package/src/viewer/public/api.js

@@ -1,5 +1,12 @@
 export const getProjects = () => fetch('/api/projects').then((r) => r.json());
 
+export const getProjectConfig = (project) =>
+  fetch(`/api/project-config?project=${encodeURIComponent(project)}`).then(async (response) => {
+    const body = await response.json();
+    if (!response.ok) throw new Error(body.error || `HTTP ${response.status}`);
+    return body;
+  });
+
 export const getRepo = async (project) => {
   const res = await fetch(`/api/repo?project=${encodeURIComponent(project)}`);
   if (!res.ok) throw new Error(`HTTP ${res.status}`);
@@ -23,3 +30,22 @@ export const postStatus = (project, id, status, reason) =>
     },
     body: JSON.stringify({ project, id, status, ...(reason ? { reason } : {}) }),
   });
+
+const postProject = (route, body) =>
+  fetch(route, {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json',
+      'x-changeledger-token': window.__CHANGELEDGER_TOKEN__,
+    },
+    body: JSON.stringify(body),
+  });
+
+export const postProjectConfig = (project, content, revision) =>
+  postProject('/api/project-config', { project, content, revision });
+
+export const postProjectPath = (project, path) =>
+  postProject('/api/project-path', { project, path });
+
+export const postProjectRemove = (project, confirm) =>
+  postProject('/api/project-remove', { project, confirm });

package/src/viewer/public/app-state.js

@@ -1,3 +1,17 @@
+export const VIEWER_STATE_KEY = 'changeledger.viewer-state.v1';
+
+const VALID_VIEWS = new Set(['board', 'table', 'graph', 'specs', 'metrics', 'projects']);
+const VALID_SORT_KEYS = new Set(['id', 'title', 'type', 'status', 'progress', 'deps']);
+let storage = null;
+
+const emptyProjectFilters = () => ({
+  type: 'all',
+  owner: 'all',
+  statuses: [],
+  showArchived: false,
+  showDiscarded: false,
+});
+
 export const state = {
   repo: null,
   lastJson: '',
@@ -9,14 +23,129 @@ export const state = {
     showArchived: false,
     showDiscarded: false,
   },
+  projectFilters: {},
   currentView: 'board',
   sortKey: 'id',
   sortDir: 1,
   currentProject: null,
   projectsList: [],
+  localOnly: false,
   globalMode: false,
 };
 
+function currentProjectFilters() {
+  return {
+    type: state.filters.type,
+    owner: state.filters.owner,
+    statuses: [...state.filters.statuses],
+    showArchived: state.filters.showArchived,
+    showDiscarded: state.filters.showDiscarded,
+  };
+}
+
+function saveCurrentProjectFilters() {
+  if (state.currentProject) state.projectFilters[state.currentProject] = currentProjectFilters();
+}
+
+function applyProjectFilters(id) {
+  const filters = state.projectFilters[id] ?? emptyProjectFilters();
+  state.filters.type = typeof filters.type === 'string' ? filters.type : 'all';
+  state.filters.owner = typeof filters.owner === 'string' ? filters.owner : 'all';
+  state.filters.statuses = new Set(
+    Array.isArray(filters.statuses)
+      ? filters.statuses.filter((value) => typeof value === 'string')
+      : [],
+  );
+  state.filters.showArchived = filters.showArchived === true;
+  state.filters.showDiscarded = filters.showDiscarded === true;
+}
+
+export function serializeViewerState() {
+  saveCurrentProjectFilters();
+  return {
+    version: 1,
+    currentProject: state.currentProject,
+    currentView: state.currentView,
+    globalMode: state.globalMode,
+    text: state.filters.text,
+    sortKey: state.sortKey,
+    sortDir: state.sortDir,
+    projects: state.projectFilters,
+  };
+}
+
+export function persistViewerState() {
+  if (!storage) return false;
+  try {
+    storage.setItem(VIEWER_STATE_KEY, JSON.stringify(serializeViewerState()));
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+export function restoreViewerState(storageLike) {
+  storage = storageLike;
+  let snapshot;
+  try {
+    snapshot = JSON.parse(storage.getItem(VIEWER_STATE_KEY) || 'null');
+  } catch {
+    return false;
+  }
+  if (snapshot?.version !== 1 || typeof snapshot !== 'object') return false;
+  if (typeof snapshot.currentProject === 'string') state.currentProject = snapshot.currentProject;
+  if (typeof snapshot.currentView === 'string') state.currentView = snapshot.currentView;
+  state.globalMode = snapshot.globalMode === true;
+  if (typeof snapshot.text === 'string') state.filters.text = snapshot.text;
+  if (typeof snapshot.sortKey === 'string') state.sortKey = snapshot.sortKey;
+  if (snapshot.sortDir === 1 || snapshot.sortDir === -1) state.sortDir = snapshot.sortDir;
+  if (
+    snapshot.projects &&
+    typeof snapshot.projects === 'object' &&
+    !Array.isArray(snapshot.projects)
+  ) {
+    state.projectFilters = snapshot.projects;
+  }
+  if (state.currentProject) applyProjectFilters(state.currentProject);
+  return true;
+}
+
+export function initializeProjects(projects, serverCurrent) {
+  state.projectsList = projects;
+  const alive = new Set(projects.filter((project) => project.alive).map((project) => project.id));
+  const selected = alive.has(state.currentProject)
+    ? state.currentProject
+    : alive.has(serverCurrent)
+      ? serverCurrent
+      : (projects.find((project) => project.alive)?.id ?? null);
+  if (selected !== state.currentProject) {
+    saveCurrentProjectFilters();
+    state.currentProject = selected;
+    if (selected) applyProjectFilters(selected);
+  }
+  if (!selected) state.globalMode = false;
+  persistViewerState();
+  return selected;
+}
+
+export function normalizeRepoState(repo) {
+  if (!VALID_VIEWS.has(state.currentView)) state.currentView = 'board';
+  if (!VALID_SORT_KEYS.has(state.sortKey)) {
+    state.sortKey = 'id';
+    state.sortDir = 1;
+  }
+  if (state.sortDir !== 1 && state.sortDir !== -1) state.sortDir = 1;
+  if (!repo.types.includes(state.filters.type)) state.filters.type = 'all';
+  const owners = new Set(repo.changes.map((change) => change.owner).filter(Boolean));
+  if (state.filters.owner !== 'all' && !owners.has(state.filters.owner))
+    state.filters.owner = 'all';
+  const statuses = new Set(repo.statuses);
+  state.filters.statuses = new Set(
+    [...state.filters.statuses].filter((status) => statuses.has(status)),
+  );
+  persistViewerState();
+}
+
 export function setRepo(json) {
   state.lastJson = json;
   state.repo = JSON.parse(json);
@@ -28,19 +157,23 @@ export function invalidateCache() {
 
 export function setTextFilter(text) {
   state.filters.text = text;
+  persistViewerState();
 }
 
 export function setTypeFilter(type) {
   state.filters.type = type;
+  persistViewerState();
 }
 
 export function setOwnerFilter(owner) {
   state.filters.owner = owner;
+  persistViewerState();
 }
 
 export function toggleStatusFilter(status) {
   if (state.filters.statuses.has(status)) state.filters.statuses.delete(status);
   else state.filters.statuses.add(status);
+  persistViewerState();
   return state.filters.statuses.has(status);
 }
 
@@ -48,29 +181,33 @@ export function clearStatusFilters() {
   state.filters.statuses.clear();
   state.filters.showArchived = false;
   state.filters.showDiscarded = false;
+  persistViewerState();
 }
 
 export function toggleShowArchived() {
   state.filters.showArchived = !state.filters.showArchived;
+  persistViewerState();
   return state.filters.showArchived;
 }
 
 export function toggleShowDiscarded() {
   state.filters.showDiscarded = !state.filters.showDiscarded;
+  persistViewerState();
   return state.filters.showDiscarded;
 }
 
-export function setView(v) {
-  state.currentView = v;
+export function setView(view) {
+  state.currentView = view;
   state.globalMode = false;
+  persistViewerState();
 }
 
 export function selectProject(id) {
+  saveCurrentProjectFilters();
   state.currentProject = id;
   state.lastJson = '';
-  state.filters.type = 'all';
-  state.filters.owner = 'all';
-  state.filters.statuses.clear();
+  applyProjectFilters(id);
+  persistViewerState();
 }
 
 export function setSortKey(key) {
@@ -79,9 +216,11 @@ export function setSortKey(key) {
     state.sortKey = key;
     state.sortDir = 1;
   }
+  persistViewerState();
 }
 
 export function toggleGlobalMode() {
   state.globalMode = !state.globalMode;
+  persistViewerState();
   return state.globalMode;
 }