@cspeach/cli 1.1.30 → 1.1.32

package/dist/projects/sort-core.js

@@ -0,0 +1,248 @@
+/**
+ * 2026-10-08 (sessions/folders, Task 13) — `cspeach files sort`, the
+ * suggesting part. Given the old project files, the sessions and the known
+ * project folders, it suggests one folder per file with a confidence
+ * (spec §3.6):
+ *
+ *   high   — a session wrote into folder F within ±2 h of the file's
+ *            createdAt, or the file is linked to a file placed in F;
+ *   medium — its input names an attached file found in exactly one project
+ *            folder's `.cspeach`;
+ *   low    — no sign; no folder suggested.
+ *
+ * Linked files form one chain (same id = versions, promotedFrom, a plan's
+ * from.specGap). A chain goes to ONE folder; a chain whose files point to
+ * different folders is flagged and gets no folder — it is never split.
+ *
+ * No writes. The only file system use is the read-only `.cspeach` lookup
+ * for medium evidence (replaceable through `holds`).
+ */
+import { readdirSync } from 'node:fs';
+import path from 'node:path';
+import { folderAboveCspeach } from '../session/backfill.js';
+import { normDir } from '../session/project-match.js';
+import { cspeachRoot, defaultCspeachRoot } from '../config/paths.js';
+const WINDOW_MS = 2 * 60 * 60 * 1000;
+const WRITE_TOOLS = new Set(['file_write', 'file_edit', 'write_file', 'edit_file']);
+const RANK = { low: 0, medium: 1, high: 2 };
+/** Does `<dir>/.cspeach` hold a file called `name` (a few levels deep)? */
+export function cspeachHolds(dir, name) {
+    const want = name.toLowerCase();
+    const walk = (d, depth) => {
+        let entries;
+        try {
+            entries = readdirSync(d, { withFileTypes: true });
+        }
+        catch {
+            return false;
+        }
+        for (const e of entries)
+            if (e.isFile() && e.name.toLowerCase() === want)
+                return true;
+        if (depth <= 0)
+            return false;
+        for (const e of entries)
+            if (e.isDirectory() && walk(path.join(d, e.name), depth - 1))
+                return true;
+        return false;
+    };
+    return walk(path.join(dir, '.cspeach'), 3);
+}
+/**
+ * Where a plan's relative pin (`.cspeach/…`, written against the folder that
+ * holds the plan's `.cspeach`) can be, on disk. Only places inside the plan's
+ * own folder are returned, so an edited pin can never reach outside it.
+ */
+export function linkedFileCandidates(planFile, rel) {
+    if (typeof rel !== 'string' || rel === '' || /\u0000/.test(rel) || path.isAbsolute(rel))
+        return [];
+    const planDir = path.dirname(path.resolve(planFile));
+    const inside = (p) => {
+        const r = path.relative(planDir, p);
+        return r !== '' && !r.startsWith('..') && !path.isAbsolute(r);
+    };
+    const tail = rel.replace(/\\/g, '/').replace(/^(\.\/)*\.cspeach\//i, '');
+    const out = [path.resolve(path.dirname(planDir), rel), path.resolve(planDir, tail)];
+    return out.filter((p, i) => inside(p) && out.findIndex((q) => normDir(q) === normDir(p)) === i);
+}
+/** Groups of indexes into `files` that must travel together. */
+export function linkChains(files) {
+    const parent = files.map((_, i) => i);
+    const find = (i) => (parent[i] === i ? i : (parent[i] = find(parent[i])));
+    const join = (a, b) => { const ra = find(a); const rb = find(b); if (ra !== rb)
+        parent[rb] = ra; };
+    const byId = new Map();
+    const byPath = new Map();
+    files.forEach((f, i) => {
+        byPath.set(normDir(f.path), i);
+        const id = f.env?.id;
+        if (typeof id !== 'string')
+            return;
+        const seen = byId.get(id);
+        if (seen === undefined)
+            byId.set(id, i);
+        else
+            join(seen, i);
+    });
+    files.forEach((f, i) => {
+        const env = f.env;
+        if (!env)
+            return;
+        const from = env.promotedFrom?.id;
+        if (typeof from === 'string' && byId.has(from))
+            join(byId.get(from), i);
+        const gap = env.artefactType === 'plan' ? env.content?.from?.specGap?.path : undefined;
+        if (typeof gap === 'string') {
+            for (const c of linkedFileCandidates(f.path, gap)) {
+                const hit = byPath.get(normDir(c));
+                if (hit !== undefined) {
+                    join(hit, i);
+                    break;
+                }
+            }
+        }
+    });
+    const groups = new Map();
+    files.forEach((_, i) => { const r = find(i); groups.set(r, [...(groups.get(r) ?? []), i]); });
+    return [...groups.values()];
+}
+const within = (p, root) => {
+    const k = normDir(p);
+    const r = normDir(root);
+    return k === r || k.startsWith(r.endsWith(path.sep) ? r : r + path.sep);
+};
+/**
+ * Ruling 24: a folder that is, or whose `.cspeach` would be, inside CSPeach's
+ * own folder (the CLI home, moved or default) is never a target.
+ */
+export function insideCliHome(dir) {
+    const roots = [cspeachRoot(), defaultCspeachRoot()];
+    return roots.some((r) => within(dir, r) || within(path.join(dir, '.cspeach'), r));
+}
+const createdMs = (f) => {
+    const t = Date.parse(String(f.env?.createdAt ?? ''));
+    return Number.isNaN(t) ? f.mtimeMs : t;
+};
+/** A folder that is just the file's own old location is no evidence. */
+const ownFolder = (file, dir) => normDir(path.join(dir, '.cspeach')) === normDir(path.dirname(file)) || normDir(dir) === normDir(path.dirname(file));
+/**
+ * high: the folder a session wrote into most within ±2 h of the file's
+ * creation. A write counts for the session's own folder (`project_dir`) when
+ * it is under it, else for the folder above a `.cspeach` in its path. A write
+ * anywhere else (a sub-folder, a temp folder) is no evidence.
+ */
+function sessionFolder(f, sessions) {
+    const created = Date.parse(String(f.env?.createdAt ?? ''));
+    if (Number.isNaN(created))
+        return null;
+    const counts = new Map();
+    for (const s of sessions) {
+        const calls = s?.toolCalls;
+        if (!Array.isArray(calls))
+            continue;
+        const pd = s?.project_dir;
+        const projectDir = typeof pd === 'string' && path.isAbsolute(pd) ? pd : null;
+        for (const c of calls) {
+            const tool = c?.tool ?? c?.name;
+            const p = c?.args?.path;
+            if (!WRITE_TOOLS.has(tool) || typeof p !== 'string' || !path.isAbsolute(p))
+                continue;
+            const at = Date.parse(String(c.completed_at ?? c.started_at ?? ''));
+            if (Number.isNaN(at) || Math.abs(at - created) > WINDOW_MS)
+                continue;
+            const dir = projectDir && within(p, projectDir) ? projectDir : folderAboveCspeach(p);
+            if (!dir || ownFolder(f.path, dir))
+                continue;
+            const k = normDir(dir);
+            const hit = counts.get(k);
+            if (hit)
+                hit.n++;
+            else
+                counts.set(k, { dir, n: 1 });
+        }
+    }
+    let best = null;
+    for (const v of counts.values())
+        if (!best || v.n > best.n)
+            best = v;
+    return best?.dir ?? null;
+}
+/** File names the envelope's input attached (`<attached file="…">`, `@name.ext`). */
+function attachedNames(input) {
+    if (typeof input !== 'string')
+        return [];
+    const names = new Set();
+    for (const m of input.matchAll(/<attached file="([^"]+)">/g))
+        names.add(path.basename(m[1].replace(/\\/g, '/')));
+    for (const m of input.matchAll(/(?:^|\s)@([^\s"'<>]+\.[A-Za-z0-9]{2,5})\b/g))
+        names.add(path.basename(m[1].replace(/\\/g, '/')));
+    return [...names];
+}
+/** medium: the one project folder whose `.cspeach` holds an attached file. */
+function attachedFolder(f, projectDirs, holds) {
+    for (const name of attachedNames(f.env?.source?.input)) {
+        const hits = projectDirs.filter((d) => !ownFolder(f.path, d) && holds(d, name));
+        if (hits.length === 1)
+            return { dir: hits[0], name };
+    }
+    return null;
+}
+export function buildSortPlan(input) {
+    const holds = input.holds ?? cspeachHolds;
+    const projectDirs = input.projectDirs
+        .filter((d) => !insideCliHome(d))
+        .filter((d, i, a) => a.findIndex((x) => normDir(x) === normDir(d)) === i);
+    const files = input.files;
+    const evidence = files.map((f) => {
+        if (!f.env)
+            return null;
+        const s = sessionFolder(f, input.sessions);
+        if (s)
+            return { level: 'high', dir: s, why: 'a session wrote there near this time' };
+        const a = attachedFolder(f, projectDirs, holds);
+        if (a)
+            return { level: 'medium', dir: a.dir, why: `its attached ${a.name} is there` };
+        return null;
+    });
+    const chains = linkChains(files)
+        .map((g) => g.sort((a, b) => createdMs(files[a]) - createdMs(files[b])))
+        .sort((a, b) => createdMs(files[a[0]]) - createdMs(files[b[0]]));
+    const rows = [];
+    for (const group of chains) {
+        const first = files[group[0]];
+        const chain = typeof first.env?.id === 'string' ? first.env.id.slice(0, 8) : path.basename(first.path).replace(/\.cspeach\.json$/, '');
+        const all = group.map((i) => evidence[i]).filter((e) => !!e);
+        const found = all.filter((e) => !insideCliHome(e.dir));
+        const best = found.reduce((m, e) => Math.max(m, RANK[e.level]), 0);
+        const top = found.filter((e) => RANK[e.level] === best);
+        const dirs = top.filter((e, i) => top.findIndex((x) => normDir(x.dir) === normDir(e.dir)) === i).map((e) => e.dir);
+        if (dirs.length > 1) {
+            for (const i of group) {
+                rows.push({ file: files[i].path, chain, target: null, confidence: 'low',
+                    why: `linked files point to different folders (${dirs.join(', ')}); pick one for all of them` });
+            }
+            continue;
+        }
+        if (dirs.length === 0) {
+            for (const i of group) {
+                rows.push({ file: files[i].path, chain, target: null, confidence: 'low',
+                    why: !files[i].env ? 'the file could not be read'
+                        : all.length > 0 ? "would be inside CSPeach's own folder" : 'no sign of where it belongs' });
+            }
+            continue;
+        }
+        const target = dirs[0];
+        const anchor = group.find((i) => evidence[i] && !insideCliHome(evidence[i].dir) && RANK[evidence[i].level] === best);
+        const level = best === RANK.high ? 'high' : 'medium';
+        for (const i of group) {
+            const own = evidence[i];
+            if (own && normDir(own.dir) === normDir(target)) {
+                rows.push({ file: files[i].path, chain, target, confidence: own.level, why: own.why });
+            }
+            else {
+                rows.push({ file: files[i].path, chain, target, confidence: level, why: `linked to ${path.basename(files[anchor].path)}` });
+            }
+        }
+    }
+    return rows;
+}

package/dist/projects/workspace-retire.js

@@ -0,0 +1,48 @@
+/**
+ * Retire the old `workspace_folder` setting (spec 2026-10-08).
+ *
+ * Files now save in the folder you start CSPeach in, and the resolver
+ * ignores `workspace_folder`. People who set it get one plain offer at
+ * start-up to remove it from config.toml. Either answer sets
+ * `workspace_folder_retired = true`, so the offer never comes back.
+ *
+ * Also: the old `.abapforge` → `.cspeach` merge offer runs only in a solo
+ * folder. A team folder must not move `<team>/.abapforge` into the shared
+ * `<team>/.cspeach`, and a home start must not target the CLI home.
+ */
+import { loadConfig, saveConfig } from '../config/loader.js';
+import { unsetConfigKey } from '../commands/config-set.js';
+import { resolveProjectFolderSync } from './project-folder.js';
+/** One-time offer to remove `workspace_folder`. Never throws. */
+export async function maybeOfferWorkspaceRetire(deps) {
+    try {
+        const cfg = await loadConfig();
+        const old = cfg.workspace_folder?.trim();
+        if (!old || cfg.workspace_folder_retired === true)
+            return;
+        deps.log(`Files now save in the folder you start CSPeach in. Your old setting pointed to ${old}; the files there stay.`);
+        let yes = false;
+        try {
+            yes = await deps.confirm('Remove the old setting?');
+        }
+        catch {
+            /* cancel = no (Ruling 20): keep the key, still save the flag */
+        }
+        if (yes)
+            unsetConfigKey(cfg, 'workspace_folder');
+        cfg.workspace_folder_retired = true;
+        await saveConfig(cfg);
+    }
+    catch {
+        /* best-effort: start-up must never fail over this offer */
+    }
+}
+/** The `.abapforge` merge offer is for solo folders only. */
+export function shouldOfferAbapforgeMigration(cwd) {
+    try {
+        return resolveProjectFolderSync(cwd).kind === 'solo';
+    }
+    catch {
+        return false;
+    }
+}