copilot-operator 0.1.0

package/dist/src/context/contextFiles.js

@@ -0,0 +1,295 @@
+/**
+ * Project files as chat context, via Context Picker.
+ *
+ * The user already maintains https://github.com/ivan-markov-666/context-picker, a VS Code
+ * and Visual Studio extension for ticking the files a project should hand to an LLM. It is
+ * not merely reusable here, it was clearly built with this exact case in mind. Its
+ * `copySelectionToDir` already carries:
+ *
+ *   appendTxtExtension  "so that tools which block source extensions (e.g. Microsoft 365
+ *                        Copilot) accept the uploads" - exactly the constraint we hit,
+ *                        since the chat's upload input rejects .ps1, .ts and friends
+ *   pathInName          flattens src/lib/app.ts into src--lib--app.ts, "lets a flat upload
+ *                        (e.g. OneDrive) keep the original folder structure in the name"
+ *   syncOnly            mirrors instead of wiping, "minimises churn for a synced folder
+ *                        such as OneDrive"
+ *
+ * So this module does not reimplement any of that. It shells out to the extension's own
+ * bridge CLI and then treats the export folder as the bot's context source.
+ *
+ * **Everything here happens in the file system, never through the browser.** The user points
+ * at the project root, ticks files in the extension, and the extension copies them into one
+ * folder on the Desktop. No Playwright, no upload form, no web picker in this path.
+ *
+ * **The folder is updated incrementally.** The extension's `syncOnly` mode writes only new
+ * and changed files and deletes the ones no longer selected, so a re-export does not rewrite
+ * a folder full of unchanged files. On top of that this module keeps a manifest of content
+ * hashes, so the bot can tell what actually changed since the last run and avoid handing the
+ * chat the same files again.
+ *
+ * If the Desktop happens to be backed up by OneDrive (Known Folder Move), the same folder
+ * also ends up in the cloud at no extra cost. That is a bonus, not the mechanism:
+ * `desktopIsSynced()` reports it, and nothing depends on it.
+ *
+ * Division of labour, which is the point of the request: **the human chooses the files** in
+ * the extension's checkbox UI, so they know exactly what the chat can see. The bot never
+ * decides what to expose.
+ */
+import { spawn } from 'node:child_process';
+import { readdir, stat, readFile, writeFile } from 'node:fs/promises';
+import { existsSync } from 'node:fs';
+import { createHash } from 'node:crypto';
+import { join, extname, resolve, sep } from 'node:path';
+import { homedir } from 'node:os';
+/**
+ * Extensions the Copilot upload input accepts, restricted to what a code project produces.
+ * Taken from the live `accept` attribute of `#upload-file-button`.
+ *
+ * Note what is absent: .ts, .ps1, .sh, .go, .rb, .yml are not all there, which is precisely
+ * why Context Picker's `appendTxtExtension` exists. Exported files end in `.txt` and keep
+ * their original extension visible in the name, e.g. `src--app.ts.txt`.
+ * The flattening itself lives in `projectMirror.ts`; this module only consumes the folder.
+ */
+export const COPILOT_ACCEPTED = new Set([
+    '.txt', '.md', '.json', '.csv', '.tsv', '.xml', '.log', '.ini', '.config',
+    '.html', '.htm', '.css', '.js', '.jsx', '.py', '.java', '.cs', '.cpp', '.c', '.h',
+    '.sql', '.php', '.pl', '.rs', '.lua', '.dart', '.yaml', '.sh', '.bash', '.tsx',
+    '.pdf', '.docx', '.xlsx', '.pptx',
+]);
+export const DEFAULT_MAX_FILES = 20;
+export const DEFAULT_MAX_TOTAL_BYTES = 25 * 1024 * 1024;
+/**
+ * The local OneDrive root.
+ *
+ * Windows sets `OneDrive` for the signed-in account, plus `OneDriveCommercial` for a work
+ * or school account when both are present. Work first: that is the tenant the chat lives in.
+ */
+export function resolveOneDriveRoot(env = process.env) {
+    const candidates = [env.OneDriveCommercial, env.OneDrive, env.OneDriveConsumer];
+    for (const c of candidates) {
+        if (c && c.trim())
+            return c;
+    }
+    const guess = join(homedir(), 'OneDrive');
+    return guess;
+}
+/**
+ * The Desktop folder.
+ *
+ * Candidates are tried in order and the first that exists wins, which is what makes this
+ * correct under OneDrive's Known Folder Move: when the Desktop is backed up, the real
+ * Desktop is `<OneDrive>\Desktop` and `%USERPROFILE%\Desktop` may not exist at all. No
+ * registry read is needed for that.
+ */
+export function resolveDesktopDir(env = process.env) {
+    const candidates = [
+        env.OneDriveCommercial ? join(env.OneDriveCommercial, 'Desktop') : null,
+        env.OneDrive ? join(env.OneDrive, 'Desktop') : null,
+        join(env.USERPROFILE ?? homedir(), 'Desktop'),
+    ].filter((c) => Boolean(c));
+    for (const c of candidates) {
+        if (existsSync(c))
+            return c;
+    }
+    return candidates[candidates.length - 1];
+}
+/** Default export folder: one folder on the Desktop. */
+export function defaultExportDir(env = process.env) {
+    return join(resolveDesktopDir(env), 'copilot-operator-context');
+}
+/**
+ * Whether the resolved Desktop is inside OneDrive, i.e. whether the export folder also
+ * reaches the cloud for free. Informational only: nothing in the bot depends on it.
+ */
+export function desktopIsSynced(env = process.env) {
+    return isInsideOneDrive(resolveDesktopDir(env), env);
+}
+/**
+ * Whether a folder sits inside a local OneDrive root, i.e. whether saving into it will
+ * actually reach the cloud. This is the whole mechanism, so it is worth checking loudly:
+ * an export folder outside OneDrive silently produces local-only copies, and the mistake
+ * only shows up later as a chat that cannot see the project.
+ */
+export function isInsideOneDrive(dir, env = process.env) {
+    const roots = [env.OneDriveCommercial, env.OneDrive, env.OneDriveConsumer].filter((r) => Boolean(r && r.trim()));
+    const target = resolve(dir).toLowerCase();
+    return roots.some((r) => {
+        const root = resolve(r).toLowerCase();
+        return target === root || target.startsWith(root + sep);
+    });
+}
+/** Lists what is currently in the export folder, newest-agnostic, sorted by name. */
+export async function listContextFiles(exportDir) {
+    let names;
+    try {
+        names = await readdir(exportDir);
+    }
+    catch {
+        return [];
+    }
+    const out = [];
+    for (const name of names.sort()) {
+        const path = join(exportDir, name);
+        const s = await stat(path).catch(() => null);
+        if (!s?.isFile())
+            continue;
+        out.push({
+            path,
+            name,
+            bytes: s.size,
+            accepted: COPILOT_ACCEPTED.has(extname(name).toLowerCase()),
+        });
+    }
+    return out;
+}
+/**
+ * Validates an export folder before anything is attached. Refusing early is much better
+ * than a half-uploaded selection, because a partial context makes Copilot answer
+ * confidently about files it never saw.
+ */
+export async function checkSelection(exportDir, cfg = {}) {
+    const maxFiles = cfg.maxFiles ?? DEFAULT_MAX_FILES;
+    const maxTotalBytes = cfg.maxTotalBytes ?? DEFAULT_MAX_TOTAL_BYTES;
+    const files = await listContextFiles(exportDir);
+    const totalBytes = files.reduce((n, f) => n + f.bytes, 0);
+    const problems = [];
+    if (files.length === 0) {
+        problems.push(`No files in ${exportDir}. Export a selection from Context Picker first.`);
+    }
+    if (files.length > maxFiles) {
+        problems.push(`${files.length} files exceeds maxFiles=${maxFiles}.`);
+    }
+    if (totalBytes > maxTotalBytes) {
+        problems.push(`${(totalBytes / 1048576).toFixed(1)} MB exceeds maxTotalBytes.`);
+    }
+    const rejected = files.filter((f) => !f.accepted);
+    if (rejected.length > 0) {
+        problems.push(`The chat upload rejects ${rejected.length} file(s): ${rejected.map((f) => f.name).join(', ')}. ` +
+            `Re-export with Context Picker's "append .txt" option.`);
+    }
+    const env = files.filter((f) => /(^|__|\.)env(\.|$)/i.test(f.name));
+    if (env.length > 0) {
+        problems.push(`Refusing to attach what look like env files: ${env.map((f) => f.name).join(', ')}.`);
+    }
+    const notes = [];
+    if (!isInsideOneDrive(exportDir)) {
+        // Not a problem: the Desktop is the target, and the bot reads it locally. It only means
+        // the folder is not additionally backed up to the cloud.
+        notes.push(`${exportDir} is not inside OneDrive, so these copies stay on this machine only. ` +
+            `Turn on OneDrive's Desktop backup, or point exportDir under ` +
+            `${resolveOneDriveRoot() ?? 'your OneDrive root'}, if you also want them in the cloud.`);
+    }
+    return { ok: problems.length === 0, files, totalBytes, problems, notes };
+}
+export const MANIFEST_NAME = '.cop-manifest.json';
+async function sha256OfFile(path) {
+    const buf = await readFile(path);
+    return createHash('sha256').update(buf).digest('hex');
+}
+export async function buildManifest(exportDir) {
+    const files = {};
+    for (const f of await listContextFiles(exportDir)) {
+        if (f.name === MANIFEST_NAME)
+            continue;
+        files[f.name] = { sha256: await sha256OfFile(f.path), bytes: f.bytes };
+    }
+    return { updatedAt: new Date().toISOString(), exportDir: resolve(exportDir), files };
+}
+export async function readManifest(manifestPath) {
+    try {
+        return JSON.parse(await readFile(manifestPath, 'utf8'));
+    }
+    catch {
+        return null;
+    }
+}
+export async function writeManifest(manifestPath, manifest) {
+    await writeFile(manifestPath, JSON.stringify(manifest, null, 2), 'utf8');
+}
+/** Compares the folder as it is now against the manifest from the previous run. */
+export function diffAgainstManifest(current, previous) {
+    const prev = previous?.files ?? {};
+    const added = [];
+    const changed = [];
+    const unchanged = [];
+    for (const [name, info] of Object.entries(current.files)) {
+        const before = prev[name];
+        if (!before)
+            added.push(name);
+        else if (before.sha256 !== info.sha256)
+            changed.push(name);
+        else
+            unchanged.push(name);
+    }
+    const removed = Object.keys(prev).filter((name) => !(name in current.files));
+    return {
+        added: added.sort(),
+        changed: changed.sort(),
+        removed: removed.sort(),
+        unchanged: unchanged.sort(),
+        toAttach: [...added, ...changed].sort(),
+    };
+}
+/** One line for the log and for the covering message to Copilot. */
+export function describeDiff(diff) {
+    if (diff.toAttach.length === 0 && diff.removed.length === 0) {
+        return 'Project context unchanged since the last run.';
+    }
+    const bits = [];
+    if (diff.added.length)
+        bits.push(`${diff.added.length} new`);
+    if (diff.changed.length)
+        bits.push(`${diff.changed.length} changed`);
+    if (diff.removed.length)
+        bits.push(`${diff.removed.length} removed`);
+    if (diff.unchanged.length)
+        bits.push(`${diff.unchanged.length} unchanged`);
+    return `Project context: ${bits.join(', ')}.`;
+}
+/**
+ * Bridge mode: re-export a saved selection by invoking Context Picker's own CLI, so a run
+ * always starts from current file contents without the user re-ticking anything.
+ *
+ * Defaults are chosen for this use case and should not be changed lightly:
+ *   appendTxt   true   the chat rejects source extensions
+ *   pathInName  true   a flat folder otherwise loses which `index.ts` is which
+ *   syncOnly    true   OneDrive should not re-upload files that did not change
+ *   includeEnvFiles false  never ship secrets to a cloud chat
+ */
+export async function exportSelection(cfg) {
+    if (!cfg.bridgePath)
+        throw new Error('contextPicker.bridgePath is not configured');
+    if (!cfg.rootDir)
+        throw new Error('contextPicker.rootDir is required when pathInName is used');
+    const request = {
+        mode: 'copyfiles',
+        rootDir: resolve(cfg.rootDir),
+        targetDir: resolve(cfg.exportDir),
+        includedFiles: (cfg.includedFiles ?? []).map((f) => resolve(f)),
+        appendTxt: true,
+        pathInName: true,
+        separator: '__',
+        syncOnly: true,
+        stripComments: cfg.stripComments ?? false,
+        removeBlankLines: cfg.removeBlankLines ?? false,
+        includeEnvFiles: cfg.includeEnvFiles ?? false,
+    };
+    return await new Promise((resolvePromise, reject) => {
+        const child = spawn(process.execPath, [cfg.bridgePath], {
+            stdio: ['pipe', 'pipe', 'pipe'],
+            windowsHide: true,
+        });
+        let out = '';
+        let err = '';
+        child.stdout.on('data', (c) => (out += c.toString('utf8')));
+        child.stderr.on('data', (c) => (err += c.toString('utf8')));
+        child.on('error', reject);
+        child.on('close', (code) => {
+            if (code !== 0)
+                return reject(new Error(`context-picker bridge exited ${code}: ${err.trim()}`));
+            const written = Number.parseInt(out.trim(), 10);
+            resolvePromise({ written: Number.isFinite(written) ? written : 0, raw: out.trim() });
+        });
+        child.stdin.end(JSON.stringify(request), 'utf8');
+    });
+}

package/dist/src/context/desktopMirror.js

@@ -0,0 +1,113 @@
+/**
+ * The projects on the Desktop: one folder each under `copilot-operator-context`.
+ *
+ * There used to be one flat folder for whatever the running session was mirroring. That was
+ * right for one project and wrong for three: every session's sync deleted the previous
+ * project's files ("no longer part of the selection"), and once the copies reached the chat
+ * as attachments, `src--main.ts.txt` from the API and `src--main.ts.txt` from the web app
+ * were the same name. So each project now has its own folder, named after it, and every
+ * flattened file carries the project's name in front — a file is then identifiable on the
+ * Desktop, in OneDrive and in the chat.
+ *
+ * Which projects: the ones on the Settings page — the default and the named others — each
+ * with its own selection of directories. The switch for keeping them all on the Desktop is
+ * `project.mirrorToDesktop`; a session's own mirror (the files attached to its first message)
+ * uses the same folder for its project whether or not the switch is on.
+ */
+import { basename, join, resolve } from 'node:path';
+import { readdir, rm, stat } from 'node:fs/promises';
+import { mirrorProject } from './projectMirror.js';
+import { defaultExportDir } from './contextFiles.js';
+const EMPTY_SELECTION = { includeDirs: [], excludeDirs: [], respectGitignore: true, includeEnvFiles: false };
+function sameFolder(a, b) {
+    const norm = (p) => resolve(p).replace(/[\\/]+$/, '').toLowerCase();
+    return a.trim() !== '' && b.trim() !== '' && norm(a) === norm(b);
+}
+/** A project's name as a folder: what the operator typed, made safe for a file system. */
+export function safeProjectName(name) {
+    return name.replace(/[<>:"/\\|?*\u0000-\u001f]/g, '-').replace(/\s+/g, ' ').trim().replace(/\.+$/, '') || 'project';
+}
+/** The projects on the Settings page, the default first, each with its selection. */
+export function knownProjects(cfg) {
+    const out = [];
+    const root = (cfg.project?.rootDir ?? '').trim();
+    if (root)
+        out.push({ name: (cfg.project?.name ?? '').trim() || basename(root) || 'project', rootDir: root, isDefault: true, mirror: cfg.project?.mirror ?? EMPTY_SELECTION });
+    for (const o of cfg.project?.others ?? [])
+        out.push({ name: o.name, rootDir: o.rootDir, isDefault: false, mirror: o.mirror ?? EMPTY_SELECTION });
+    return out;
+}
+/** What to call the folder for a session's project: its Settings name, else the folder's own. */
+export function projectNameFor(rootDir, cfg) {
+    const known = knownProjects(cfg).find((p) => sameFolder(p.rootDir, rootDir));
+    return safeProjectName(known?.name ?? basename(resolve(rootDir)) ?? 'project');
+}
+/** The Desktop folder that holds one subfolder per project. */
+export function contextRoot(cfg) {
+    return cfg.resolved.mirrorTargetDir ?? defaultExportDir();
+}
+export function projectTargetDir(cfg, projectName) {
+    return join(contextRoot(cfg), safeProjectName(projectName));
+}
+/**
+ * Files left directly in the context root by the flat layout this replaced. They would
+ * otherwise sit in OneDrive as stale copies with no project in their name, which is exactly
+ * the confusion the folders exist to end. Only files, only ours by the look of them.
+ */
+export async function removeLegacyFlatMirror(cfg) {
+    const root = contextRoot(cfg);
+    const removed = [];
+    for (const entry of await readdir(root).catch(() => [])) {
+        const path = join(root, entry);
+        const info = await stat(path).catch(() => null);
+        if (!info?.isFile())
+            continue;
+        if (!/\.txt$/i.test(entry) && !entry.includes('--'))
+            continue;
+        await rm(path, { force: true }).catch(() => undefined);
+        removed.push(entry);
+    }
+    return removed;
+}
+/** Brings one project's Desktop folder in line with its selection. */
+export async function mirrorKnownProject(cfg, project) {
+    const name = safeProjectName(project.name);
+    const targetDir = projectTargetDir(cfg, name);
+    const result = await mirrorProject({
+        rootDir: project.rootDir,
+        includeDirs: project.mirror.includeDirs.length ? project.mirror.includeDirs : ['.'],
+        excludeDirs: project.mirror.excludeDirs,
+        targetDir,
+        namePrefix: name,
+        separator: cfg.projectMirror.separator,
+        txtMode: cfg.projectMirror.txtMode,
+        respectGitignore: project.mirror.respectGitignore,
+        ignoreDirs: cfg.projectMirror.ignoreDirs,
+        includeEnvFiles: project.mirror.includeEnvFiles,
+        maxFileBytes: cfg.projectMirror.maxFileBytes,
+    });
+    return { name, rootDir: project.rootDir, targetDir, result };
+}
+/** Every known project, when the switch is on. Nothing when it is off. */
+export async function mirrorAllProjects(cfg) {
+    if (!cfg.project?.mirrorToDesktop)
+        return [];
+    await removeLegacyFlatMirror(cfg);
+    const out = [];
+    for (const p of knownProjects(cfg))
+        out.push(await mirrorKnownProject(cfg, p));
+    return out;
+}
+/** Removes every known project's folder from the Desktop. The switch going off. */
+export async function removeProjectMirrors(cfg) {
+    const removed = [];
+    for (const p of knownProjects(cfg)) {
+        const dir = projectTargetDir(cfg, p.name);
+        const info = await stat(dir).catch(() => null);
+        if (!info?.isDirectory())
+            continue;
+        await rm(dir, { recursive: true, force: true });
+        removed.push(dir);
+    }
+    return removed;
+}