@devmarketplacenpm/devmp 0.1.1-beta.5

package/lib/completion.js

@@ -0,0 +1,190 @@
+"use strict";
+
+const fs = require("fs/promises");
+const path = require("path");
+const { IGNORE_DIRS, isSecretPath } = require("./workspace");
+
+// Tab completion for the composer. Two things are worth completing: the slash
+// commands, which are otherwise only discoverable through /help, and @-paths,
+// which are useless if you have to type the whole path from memory.
+
+/** Every command the shell actually implements, in the order /help lists them. */
+const SLASH_COMMANDS = [
+  "/help",
+  "/init",
+  "/status",
+  "/doctor",
+  "/login",
+  "/mode",
+  "/plan",
+  "/model",
+  "/permissions",
+  "/diff",
+  "/undo",
+  "/jobs",
+  "/gigs",
+  "/new",
+  "/compact",
+  "/resume",
+  "/quit",
+  "/exit",
+];
+
+/** Arguments worth suggesting once the command itself is complete. */
+const SLASH_ARGUMENTS = {
+  "/mode": ["auto", "chat", "plan", "act"],
+  "/permissions": ["ask", "edits", "commands", "auto"],
+  "/model": ["openai", "anthropic", "ollama"],
+  "/jobs": ["stop"],
+  "/init": ["update"],
+  "/login": ["signup"],
+};
+
+const MAX_OPTIONS = 24;
+
+function longestCommonPrefix(values) {
+  if (!values.length) return "";
+  let prefix = values[0];
+  for (const value of values.slice(1)) {
+    let i = 0;
+    while (i < prefix.length && i < value.length && prefix[i] === value[i]) i += 1;
+    prefix = prefix.slice(0, i);
+    if (!prefix) break;
+  }
+  return prefix;
+}
+
+/**
+ * The whitespace-delimited token the caret sits in. Returned as glyph indices,
+ * because that is what the composer's caret counts in — byte or UTF-16 offsets
+ * would drift on any line containing an emoji or an accented character.
+ */
+function tokenAt(glyphs, caret) {
+  let from = caret;
+  while (from > 0 && !/\s/.test(glyphs[from - 1])) from -= 1;
+  let to = caret;
+  while (to < glyphs.length && !/\s/.test(glyphs[to])) to += 1;
+  return { from, to, value: glyphs.slice(from, to).join("") };
+}
+
+/**
+ * Turn a candidate list into an edit. One match completes outright; several
+ * advance to the common prefix and report the choices, which is the behaviour
+ * a shell trains people to expect.
+ */
+function chooseCompletion({ from, to, prefix, candidates, suffix = " " }) {
+  const matches = candidates.filter((item) => item.startsWith(prefix));
+  if (!matches.length) return null;
+  if (matches.length === 1) {
+    const only = matches[0];
+    return {
+      from,
+      to,
+      insert: only + (only.endsWith("/") ? "" : suffix),
+      options: [],
+    };
+  }
+  const common = longestCommonPrefix(matches);
+  return {
+    from,
+    to,
+    // No progress to make: leave the text alone and just show the choices.
+    insert: common.length > prefix.length ? common : prefix,
+    options: matches.slice(0, MAX_OPTIONS),
+    truncated: Math.max(0, matches.length - MAX_OPTIONS),
+  };
+}
+
+function completeSlash(glyphs, caret) {
+  const token = tokenAt(glyphs, caret);
+  const line = glyphs.join("");
+  if (!line.startsWith("/")) return null;
+
+  // First token: complete the command name itself.
+  if (token.from === 0) {
+    return chooseCompletion({
+      from: token.from,
+      to: token.to,
+      prefix: token.value,
+      candidates: SLASH_COMMANDS,
+    });
+  }
+
+  // Later tokens: complete that command's known arguments, if it has any.
+  const command = line.slice(0, line.search(/\s/) === -1 ? line.length : line.search(/\s/));
+  const args = SLASH_ARGUMENTS[command];
+  if (!args) return null;
+  return chooseCompletion({
+    from: token.from,
+    to: token.to,
+    prefix: token.value,
+    candidates: args,
+  });
+}
+
+async function completeMention(rootDir, glyphs, caret) {
+  const token = tokenAt(glyphs, caret);
+  if (!token.value.startsWith("@")) return null;
+
+  const partial = token.value.slice(1);
+  const slash = partial.lastIndexOf("/");
+  const dir = slash === -1 ? "" : partial.slice(0, slash + 1);
+  const base = slash === -1 ? partial : partial.slice(slash + 1);
+
+  // Completion must not become a way to walk out of the workspace, and it must
+  // not name files the agent is forbidden to read.
+  const target = path.resolve(rootDir, dir);
+  const root = path.resolve(rootDir);
+  if (target !== root && !target.startsWith(root + path.sep)) return null;
+
+  let entries;
+  try {
+    entries = await fs.readdir(target, { withFileTypes: true });
+  } catch {
+    return null;
+  }
+
+  const candidates = [];
+  for (const entry of entries) {
+    if (entry.isDirectory() && IGNORE_DIRS.has(entry.name)) continue;
+    // Hidden files stay hidden until you ask for them by typing the dot.
+    if (entry.name.startsWith(".") && !base.startsWith(".")) continue;
+    const rel = dir + entry.name;
+    if (isSecretPath(rel)) continue;
+    candidates.push(entry.isDirectory() ? `${rel}/` : rel);
+  }
+  candidates.sort();
+
+  const result = chooseCompletion({
+    from: token.from,
+    to: token.to,
+    prefix: partial,
+    candidates,
+  });
+  if (!result) return null;
+  return {
+    ...result,
+    insert: `@${result.insert}`,
+    options: result.options.map((item) => `@${item}`),
+  };
+}
+
+/**
+ * Resolve a Tab press. Returns null when there is nothing sensible to do, so
+ * the composer can leave the text untouched rather than guessing.
+ */
+async function completeInput(rootDir, value, caret) {
+  const glyphs = Array.from(value);
+  const position = Math.max(0, Math.min(caret, glyphs.length));
+  const mention = await completeMention(rootDir, glyphs, position);
+  if (mention) return mention;
+  return completeSlash(glyphs, position);
+}
+
+module.exports = {
+  completeInput,
+  completeSlash,
+  completeMention,
+  SLASH_COMMANDS,
+  SLASH_ARGUMENTS,
+};

package/lib/config.js

@@ -0,0 +1,172 @@
+'use strict';
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+
+// Environment resolution. Defaults to production; `--local` (or env overrides)
+// points at a locally running backend/frontend. Kept identical to the existing
+// device-auth client so sessions are interchangeable.
+//
+// An environment is a *pair* of URLs. They were resolved independently, so
+// `--api-base-url <dev>` kept the production frontend and login opened an
+// approval page on a different environment than the device code was created
+// in — the code is simply not found there. Pairs stay together here.
+const ENVIRONMENTS = {
+  production: {
+    apiBaseUrl: 'https://api-prod.devmarketplace.com/api',
+    frontendBaseUrl: 'https://beta.devmarketplace.com',
+  },
+  dev: {
+    apiBaseUrl: 'https://api-dev.devmarketplace.com/api',
+    frontendBaseUrl: 'https://dev.devmarketplace.com',
+  },
+  local: {
+    apiBaseUrl: 'http://localhost:8000/api',
+    frontendBaseUrl: 'http://localhost:3000',
+  },
+};
+const ENVIRONMENT_NAMES = Object.keys(ENVIRONMENTS);
+
+// Settings a config file may carry. Anything else in the file is ignored rather
+// than rejected, so a newer client's config does not break an older one.
+const CONFIG_KEYS = new Set([
+  'apiBaseUrl',
+  'frontendBaseUrl',
+  'local',
+  'env',
+  'provider',
+  'model',
+  'maxFiles',
+  'yes',
+  'allowCommands',
+  'permissions',
+  'mode',
+]);
+
+const GLOBAL_CONFIG_PATH = () =>
+  process.env.DEVMP_CONFIG ||
+  path.join(os.homedir(), '.devmarketplace', 'config.json');
+
+const PROJECT_CONFIG_NAME = '.devmp.json';
+
+/**
+ * Read one config file. A missing file is the normal case; a malformed one is
+ * reported once and then ignored, because refusing to start over a stray comma
+ * in a convenience file would be a worse failure than the file not existing.
+ */
+function readConfigFile(file, onWarn) {
+  let raw;
+  try {
+    raw = fs.readFileSync(file, 'utf8');
+  } catch {
+    return {};
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch (error) {
+    onWarn?.(`Ignoring ${file}: ${error.message}`);
+    return {};
+  }
+  if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+    onWarn?.(`Ignoring ${file}: expected a JSON object.`);
+    return {};
+  }
+  const out = {};
+  for (const [key, value] of Object.entries(parsed)) {
+    if (CONFIG_KEYS.has(key)) out[key] = value;
+  }
+  return out;
+}
+
+/**
+ * Merge the config files that apply to this invocation.
+ *
+ * A project file sits next to the code it describes and wins over the global
+ * one, which is the order people expect from every other tool that does this.
+ */
+function loadConfigFiles(cwd, onWarn) {
+  const global = readConfigFile(GLOBAL_CONFIG_PATH(), onWarn);
+  const project = readConfigFile(
+    path.join(path.resolve(cwd || process.cwd()), PROJECT_CONFIG_NAME),
+    onWarn,
+  );
+  return { ...global, ...project };
+}
+
+function stripTrailingSlash(value) {
+  return String(value).replace(/\/+$/, '');
+}
+
+/**
+ * Resolve the effective settings for this invocation.
+ *
+ * Precedence, highest first: an explicit flag, then the environment, then the
+ * project's `.devmp.json`, then the global config, then the built-in default.
+ * A flag typed now always beats a file written earlier.
+ */
+function resolveConfig(flags = {}, { cwd, onWarn } = {}) {
+  const file = loadConfigFiles(cwd, onWarn);
+
+  const local = flags.local === true || (flags.local === undefined && file.local === true);
+
+  // `--local` is kept as the shorthand it always was; `--env <name>` is the
+  // general form. An unknown name falls back to production rather than failing,
+  // so a typo cannot strand someone with no usable target.
+  const requested = flags.env || process.env.DEVMP_ENV || file.env;
+  const envName = local
+    ? 'local'
+    : ENVIRONMENT_NAMES.includes(requested)
+      ? requested
+      : 'production';
+  const chosen = ENVIRONMENTS[envName];
+
+  const apiBaseUrl =
+    flags['api-base-url'] ||
+    process.env.DEVMP_API_BASE_URL ||
+    file.apiBaseUrl ||
+    chosen.apiBaseUrl;
+
+  const frontendBaseUrl =
+    flags['frontend-url'] ||
+    process.env.DEVMP_FRONTEND_URL ||
+    file.frontendBaseUrl ||
+    chosen.frontendBaseUrl;
+
+  return {
+    env: envName,
+    // Whether the user explicitly chose the API target this invocation. When
+    // false, commands keep using the URL the session was created against
+    // (so `devmp run` after `devmp login --local` still hits localhost).
+    apiExplicit: Boolean(
+      flags.local ||
+        flags.env ||
+        flags['api-base-url'] ||
+        file.apiBaseUrl ||
+        file.env ||
+        file.local,
+    ),
+    apiBaseUrl: stripTrailingSlash(apiBaseUrl),
+    frontendBaseUrl: stripTrailingSlash(frontendBaseUrl),
+    // Defaults a command may fall back to when no flag was given.
+    defaults: {
+      provider: typeof file.provider === 'string' ? file.provider : undefined,
+      model: typeof file.model === 'string' ? file.model : undefined,
+      maxFiles: Number.isInteger(file.maxFiles) ? file.maxFiles : undefined,
+      yes: file.yes === true,
+      allowCommands: file.allowCommands === true,
+      permissions:
+        typeof file.permissions === 'string' ? file.permissions : undefined,
+      mode: typeof file.mode === 'string' ? file.mode : undefined,
+    },
+  };
+}
+
+module.exports = {
+  resolveConfig,
+  loadConfigFiles,
+  GLOBAL_CONFIG_PATH,
+  PROJECT_CONFIG_NAME,
+  CONFIG_KEYS,
+};

package/lib/diff.js

@@ -0,0 +1,216 @@
+"use strict";
+
+const { color } = require("./ui");
+
+const CONTEXT_LINES = 3;
+const MAX_LCS_CELLS = 2_000_000;
+
+function linesOf(value) {
+  if (value === null || value === undefined || value === "") return [];
+  const lines = String(value).split("\n");
+  if (lines.at(-1) === "") lines.pop();
+  return lines;
+}
+
+function fallbackOps(before, after) {
+  let prefix = 0;
+  while (
+    prefix < before.length &&
+    prefix < after.length &&
+    before[prefix] === after[prefix]
+  ) {
+    prefix += 1;
+  }
+  let suffix = 0;
+  while (
+    suffix < before.length - prefix &&
+    suffix < after.length - prefix &&
+    before[before.length - 1 - suffix] === after[after.length - 1 - suffix]
+  ) {
+    suffix += 1;
+  }
+  return [
+    ...before.slice(0, prefix).map((line) => ({ type: " ", line })),
+    ...before
+      .slice(prefix, before.length - suffix)
+      .map((line) => ({ type: "-", line })),
+    ...after
+      .slice(prefix, after.length - suffix)
+      .map((line) => ({ type: "+", line })),
+    ...before
+      .slice(before.length - suffix)
+      .map((line) => ({ type: " ", line })),
+  ];
+}
+
+/** A small dependency-free line diff. LCS gives clean hunks for ordinary
+ * source files; very large comparisons use a bounded prefix/suffix fallback. */
+function lineOps(beforeText, afterText) {
+  const before = linesOf(beforeText);
+  const after = linesOf(afterText);
+  const width = after.length + 1;
+  const cells = (before.length + 1) * width;
+  if (cells > MAX_LCS_CELLS) return fallbackOps(before, after);
+
+  const table = new Uint32Array(cells);
+  for (let i = before.length - 1; i >= 0; i -= 1) {
+    for (let j = after.length - 1; j >= 0; j -= 1) {
+      const at = i * width + j;
+      table[at] =
+        before[i] === after[j]
+          ? table[(i + 1) * width + j + 1] + 1
+          : Math.max(table[(i + 1) * width + j], table[at + 1]);
+    }
+  }
+
+  const ops = [];
+  let i = 0;
+  let j = 0;
+  while (i < before.length || j < after.length) {
+    if (i < before.length && j < after.length && before[i] === after[j]) {
+      ops.push({ type: " ", line: before[i] });
+      i += 1;
+      j += 1;
+    } else if (
+      j < after.length &&
+      (i >= before.length ||
+        table[i * width + j + 1] >= table[(i + 1) * width + j])
+    ) {
+      ops.push({ type: "+", line: after[j] });
+      j += 1;
+    } else {
+      ops.push({ type: "-", line: before[i] });
+      i += 1;
+    }
+  }
+  return ops;
+}
+
+function hunkRanges(ops) {
+  const changed = [];
+  for (let i = 0; i < ops.length; i += 1) {
+    if (ops[i].type !== " ") changed.push(i);
+  }
+  if (!changed.length) return [];
+
+  const ranges = [];
+  let start = Math.max(0, changed[0] - CONTEXT_LINES);
+  let end = Math.min(ops.length, changed[0] + CONTEXT_LINES + 1);
+  for (const index of changed.slice(1)) {
+    const nextStart = Math.max(0, index - CONTEXT_LINES);
+    const nextEnd = Math.min(ops.length, index + CONTEXT_LINES + 1);
+    if (nextStart <= end) end = Math.max(end, nextEnd);
+    else {
+      ranges.push([start, end]);
+      start = nextStart;
+      end = nextEnd;
+    }
+  }
+  ranges.push([start, end]);
+  return ranges;
+}
+
+function coordinates(ops, start, end) {
+  let oldLine = 1;
+  let newLine = 1;
+  for (const op of ops.slice(0, start)) {
+    if (op.type !== "+") oldLine += 1;
+    if (op.type !== "-") newLine += 1;
+  }
+  let oldCount = 0;
+  let newCount = 0;
+  for (const op of ops.slice(start, end)) {
+    if (op.type !== "+") oldCount += 1;
+    if (op.type !== "-") newCount += 1;
+  }
+  return { oldLine, newLine, oldCount, newCount };
+}
+
+function formatUnifiedDiff({ path, before, after }) {
+  const beforeExists = before !== null && before !== undefined;
+  const afterExists = after !== null && after !== undefined;
+  if (before === after) return "";
+  const ops = lineOps(before, after);
+  const output = [
+    `--- ${beforeExists ? `a/${path}` : "/dev/null"}`,
+    `+++ ${afterExists ? `b/${path}` : "/dev/null"}`,
+  ];
+  for (const [start, end] of hunkRanges(ops)) {
+    const c = coordinates(ops, start, end);
+    output.push(
+      `@@ -${c.oldLine},${c.oldCount} +${c.newLine},${c.newCount} @@`
+    );
+    for (const op of ops.slice(start, end)) output.push(`${op.type}${op.line}`);
+  }
+  return output.join("\n");
+}
+
+/**
+ * Styled diff lines. Returned rather than printed so the interactive screen can
+ * route them through its own writer and keep its row accounting intact.
+ *
+ * `indent` keeps a reviewed diff aligned with the rest of the transcript, and
+ * `maxLines` stops a whole generated file from burying the approval prompt —
+ * the point of review is to be readable, and nobody audits 400 lines in a
+ * terminal before pressing y.
+ */
+function styleDiffLines(diff, { indent = "", maxLines = 0 } = {}) {
+  if (!diff) return [];
+  const raw = diff.split("\n");
+  const shown = maxLines > 0 && raw.length > maxLines ? raw.slice(0, maxLines) : raw;
+  const out = shown.map((line) => {
+    if (line.startsWith("+++") || line.startsWith("---")) {
+      return `${indent}${color.bold(line)}`;
+    }
+    if (line.startsWith("+")) return `${indent}${color.green(line)}`;
+    if (line.startsWith("-")) return `${indent}${color.red(line)}`;
+    if (line.startsWith("@@")) return `${indent}${color.cyan(line)}`;
+    return `${indent}${color.dim(line)}`;
+  });
+  if (shown.length < raw.length) {
+    out.push(
+      `${indent}${color.dim(`… ${raw.length - shown.length} more diff line(s)`)}`
+    );
+  }
+  return out;
+}
+
+/** Counts for a compact summary, so a create does not need a full +++ dump. */
+function diffStats(diff) {
+  let added = 0;
+  let removed = 0;
+  for (const line of String(diff || "").split("\n")) {
+    if (line.startsWith("+++") || line.startsWith("---")) continue;
+    if (line.startsWith("+")) added += 1;
+    else if (line.startsWith("-")) removed += 1;
+  }
+  return { added, removed };
+}
+
+function printUnifiedDiff(diff) {
+  for (const line of styleDiffLines(diff)) console.log(line);
+}
+
+function checkpointDiff(checkpoint) {
+  if (!checkpoint?.files) return "";
+  return Object.entries(checkpoint.files)
+    .sort(([a], [b]) => a.localeCompare(b))
+    .map(([path, snapshots]) =>
+      formatUnifiedDiff({
+        path,
+        before: snapshots.before?.exists ? snapshots.before.content : null,
+        after: snapshots.after?.exists ? snapshots.after.content : null,
+      })
+    )
+    .filter(Boolean)
+    .join("\n\n");
+}
+
+module.exports = {
+  checkpointDiff,
+  diffStats,
+  formatUnifiedDiff,
+  lineOps,
+  printUnifiedDiff,
+  styleDiffLines,
+};