mouaif 0.3.0

package/src/projects.js

@@ -0,0 +1,285 @@
+'use strict';
+
+// Project / folder picker — files API + registered-project store.
+//
+// Implements docs/decisions.md section 4 (full filesystem browse) and the
+// "new project opens a folder list + create new folder" rule from
+// .github/copilot-instructions.md.
+//
+// Two surfaces:
+//
+//   Filesystem surface (the picker):
+//     listDir(absPath)        -> { dir, entries: [{ name, path, hasChildren }] }
+//     createDir(absPath)      -> { path }
+//
+//   Registered-project surface (the user's chosen projects):
+//     listProjects()          -> [{ id, path, name, createdAt }]
+//     getProject(id)          -> { id, path, name, createdAt } | null
+//     registerProject(path)   -> { id, path, name, createdAt }
+//     removeProject(id)       -> true | false
+//
+// Registered projects are stored in the app settings under the `projects`
+// key. They survive restarts. Removing a registered project does NOT
+// delete the folder on disk.
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const crypto = require('crypto');
+const settings = require('./settings.js');
+
+const ALLOW_ANY_ROOT = process.env.MOUAIF_ALLOW_ANY_ROOT === '1';
+
+// ---- Path safety --------------------------------------------------------
+
+function isAbsolutePath(p) {
+  return typeof p === 'string' && path.isAbsolute(p);
+}
+
+function isUnderHome(absPath) {
+  const home = os.homedir();
+  const resolved = path.resolve(absPath);
+  const homeResolved = path.resolve(home);
+  // Same path, or a descendant.
+  if (resolved === homeResolved) return true;
+  const rel = path.relative(homeResolved, resolved);
+  return !!rel && !rel.startsWith('..') && !path.isAbsolute(rel);
+}
+
+function ensureSafeRoot(absPath) {
+  if (!isAbsolutePath(absPath)) {
+    const e = new Error('Path must be absolute');
+    e.code = 'EBADPATH';
+    throw e;
+  }
+  if (!ALLOW_ANY_ROOT && !isUnderHome(absPath)) {
+    const e = new Error('Path must be under the user home. Set MOUAIF_ALLOW_ANY_ROOT=1 to opt out.');
+    e.code = 'EOUTSIDE_HOME';
+    throw e;
+  }
+  return path.resolve(absPath);
+}
+// The top-most directory the file editor / picker may browse to. With
+// MOUAIF_ALLOW_ANY_ROOT the whole filesystem is reachable so the boundary
+// is the root path; otherwise it is the user's home. Used by the frontend
+// to clamp the Up button at the natural top so it never asks the server
+// for a directory that would fail the home guard.
+function browseTop(absPath) {
+  if (!absPath || !isAbsolutePath(absPath)) return null;
+  if (ALLOW_ANY_ROOT) {
+    const root = path.parse(path.resolve(absPath)).root;
+    return root;
+  }
+  return os.homedir();
+}
+// True when `absPath` sits at or above the browse boundary (home, or /)
+// for the given home/ALLOW key — i.e. there is no parent to go up to.
+function isBrowseTop(absPath) {
+  const top = browseTop(absPath);
+  if (!top) return true;
+  const resolved = path.resolve(absPath || '');
+  const topResolved = path.resolve(top);
+  return resolved === topResolved;
+}
+
+// ---- Filesystem surface -------------------------------------------------
+
+function listDir(absPath) {
+  const safe = ensureSafeRoot(absPath);
+  let names;
+  try {
+    names = fs.readdirSync(safe);
+  } catch (e) {
+    // Surface typed errors so the UI can show "permission denied" vs "no such dir".
+    const wrapped = new Error(e.message);
+    wrapped.code = e.code || 'EREAD';
+    wrapped.path = safe;
+    throw wrapped;
+  }
+  const entries = [];
+  for (const name of names) {
+    // Skip hidden by default — chat list / project picker doesn't need dotfiles.
+    if (name.startsWith('.')) continue;
+    const full = path.join(safe, name);
+    let stat;
+    try { stat = fs.statSync(full); } catch { continue; }
+    if (!stat.isDirectory()) continue;
+    entries.push({
+      name,
+      path: full,
+      hasChildren: hasImmediateSubdirs(full)
+    });
+  }
+  // Stable order: case-insensitive name.
+  entries.sort((a, b) => a.name.toLowerCase().localeCompare(b.name.toLowerCase()));
+  return { dir: safe, entries };
+}
+
+function hasImmediateSubdirs(absPath) {
+  let names;
+  try { names = fs.readdirSync(absPath); } catch { return false; }
+  for (const n of names) {
+    if (n.startsWith('.')) continue;
+    try {
+      const st = fs.statSync(path.join(absPath, n));
+      if (st.isDirectory()) return true;
+    } catch { /* ignore */ }
+  }
+  return false;
+}
+
+function createDir(absPath) {
+  const safe = ensureSafeRoot(absPath);
+  try {
+    fs.mkdirSync(safe, { recursive: false });
+  } catch (e) {
+    if (e.code === 'EEXIST') {
+      const wrapped = new Error('Directory already exists');
+      wrapped.code = 'EEXIST';
+      wrapped.path = safe;
+      throw wrapped;
+    }
+    throw e;
+  }
+  return { path: safe };
+}
+
+// ---- Registered-project surface ----------------------------------------
+
+function id() {
+  return crypto.randomBytes(8).toString('hex');
+}
+
+function readProjects() {
+  const app = settings.getApp();
+  const list = Array.isArray(app.projects) ? app.projects : [];
+  // Defensive copy, validated.
+  return list.filter(p => p && typeof p.path === 'string' && typeof p.id === 'string');
+}
+
+function writeProjects(list) {
+  // Single shallow patch — settings.setApp does the merge.
+  settings.setApp({ projects: list });
+}
+
+function emptyTotalCost() {
+  return { total: 0, known: false, currency: 'USD', knownCount: 0 };
+}
+function normalizeTotalCost(value) {
+  if (!value || typeof value.total !== 'number' || !Number.isFinite(value.total)) return emptyTotalCost();
+  const knownCount = Number.isInteger(value.knownCount) && value.knownCount >= 0
+    ? value.knownCount
+    : (value.known === true ? 1 : 0);
+  return {
+    total: Math.max(0, value.total),
+    known: knownCount > 0,
+    currency: 'USD',
+    knownCount
+  };
+}
+function listProjects() {
+  return readProjects().map((project) => ({
+    ...project,
+    totalCost: normalizeTotalCost(project.totalCost)
+  }));
+}
+function setProjectTotalCost(projectDir, totalCost) {
+  const list = readProjects();
+  const idx = list.findIndex((project) => path.resolve(project.path) === path.resolve(projectDir));
+  if (idx < 0) return null;
+  const normalized = normalizeTotalCost(totalCost);
+  list[idx] = { ...list[idx], totalCost: normalized };
+  writeProjects(list);
+  return normalized;
+}
+function adjustProjectTotalCost(projectDir, totalDelta, knownCountDelta) {
+  const list = readProjects();
+  const idx = list.findIndex((project) => path.resolve(project.path) === path.resolve(projectDir));
+  if (idx < 0) return null;
+  const current = normalizeTotalCost(list[idx].totalCost);
+  const knownCount = Math.max(0, current.knownCount + knownCountDelta);
+  const totalCost = {
+    total: knownCount > 0 ? Math.max(0, current.total + totalDelta) : 0,
+    known: knownCount > 0,
+    currency: 'USD',
+    knownCount
+  };
+  list[idx] = { ...list[idx], totalCost };
+  writeProjects(list);
+  return totalCost;
+}
+
+function getProject(pid) {
+  return readProjects().find(p => p.id === pid) || null;
+}
+
+function registerProject(absPath) {
+  const safe = ensureSafeRoot(absPath);
+  // The folder must exist. Use stat, not existsSync, to get a real error
+  // for ENOTDIR / EACCES.
+  const stat = fs.statSync(safe);
+  if (!stat.isDirectory()) {
+    const e = new Error('Path is not a directory');
+    e.code = 'ENOTDIR';
+    e.path = safe;
+    throw e;
+  }
+  const existing = readProjects();
+  // Dedupe by canonical path.
+  const dupe = existing.find(p => path.resolve(p.path) === safe);
+  if (dupe) return dupe;
+  const row = {
+id: id(),
+path: safe,
+name: path.basename(safe),
+createdAt: new Date().toISOString(),
+totalCost: emptyTotalCost()
+};
+  writeProjects([...existing, row]);
+  return row;
+}
+
+function removeProject(pid) {
+  const before = readProjects();
+  const after = before.filter(p => p.id !== pid);
+  if (after.length === before.length) return false;
+  writeProjects(after);
+  return true;
+}
+
+// Rename a registered project's display label. The on-disk folder
+// is not touched. Trims and validates the new name; returns null if
+// the project doesn't exist or the name is empty.
+function renameProject(pid, newName) {
+  if (!pid || typeof pid !== 'string') return null;
+  if (typeof newName !== 'string') return null;
+  const trimmed = newName.trim();
+  if (!trimmed) return null;
+  const list = readProjects();
+  const idx = list.findIndex(p => p.id === pid);
+  if (idx < 0) return null;
+  const updated = Object.assign({}, list[idx], { name: trimmed });
+  list[idx] = updated;
+  writeProjects(list);
+  return updated;
+}
+
+module.exports = {
+  // filesystem
+  listDir,
+  createDir,
+  // registered projects
+  listProjects,
+  getProject,
+  registerProject,
+  removeProject,
+  renameProject,
+  setProjectTotalCost,
+  adjustProjectTotalCost,
+// helpers (exported for tests + future inspector)
+isUnderHome,
+ensureSafeRoot,
+browseTop,
+isBrowseTop,
+ALLOW_ANY_ROOT
+};

package/src/promptProfiles.js

@@ -0,0 +1,256 @@
+'use strict';
+
+// Prompt-size profiles.
+//
+// Implements the "Three prompt-size profiles" feature from
+// .github/copilot-instructions.md §4. The chat record carries a
+// `promptSize` field ('very-small' | 'average' | 'extensive') and
+// `handleChatStream` in src/index.js prepends the matching profile's
+// system message to the upstream `messages` array, immediately before
+// any custom-prompt block.
+//
+// Resolution order (decisions §2): defaults -> app -> project.
+//   - chat.promptSize (per-chat override; see src/chats.js) wins if set
+//   - else settings.getResolved(projectDir).promptSize
+//   - else 'average'  (the DEFAULTS floor in src/settings.js)
+//
+// Profiles share a provider-neutral core: changing the size adds detail,
+// not conflicting rules about autonomy, safety, tools, or progress.
+// Tool declarations are sized separately by reduceToolSpecs below.
+//
+// Profiles:
+//   - very-small : compact core + on-demand tool-schema discovery.
+//   - average    : the same core + an explicit inspect/edit/verify loop.
+//     The recommended default, with full tool schemas.
+//   - extensive  : all average guidance + planning, verification, and
+//     concrete workflow examples. Also uses full tool schemas.
+//
+// Public surface:
+//   PROFILES                          : { 'very-small', 'average', 'extensive' }
+//   DEFAULT_PROFILE                   : 'average'
+//   isValidProfile(value)             : boolean
+//   profileSystemMessage(value)       : string
+//   listProfiles()                    : [{ id, label, description, summary }, ...]
+//   resolveProfile({ chat, projectDir }): { id, label, description, summary, systemMessage }
+//   describeProfile(value)            : { id, label, description, summary, systemMessage }
+//                                       or null if value is unknown
+
+const CORE_GUIDANCE = [
+  'You are a coding assistant running inside mouaif, a mobile chat UI.',
+  '',
+  '- Be concise by default. Use short Markdown, language-tagged code fences, and project-relative paths.',
+  '- Follow applicable project and custom instructions, respecting higher-priority instructions.',
+  '- Make reasonable, reversible decisions; state assumptions briefly. Ask when ambiguity affects scope, safety, or correctness.',
+  '- Ask before destructive actions, full-file rewrites, dependency installs, or pushes unless explicitly authorized. Preserve unrelated user work.',
+  '- Use only enabled tools and respect authorization gates. If a tool schema is missing, use discover_tool before calling it.',
+  '- Inspect before editing; make focused changes, run relevant checks, and fix introduced failures. Shell has no stdin: use non-interactive commands, never a REPL.',
+  '- If report_progress is enabled, call it at the start of every task with status: "running" and at completion with status: "completed" and current equal to total. Use status: "failed" if blocked; never mark unfinished work completed.',
+  '- Never invent project facts or test results. Finish with the outcome, checks run, and any limitations. Do not expose secrets.'
+].join('\n');
+const WORKFLOW_GUIDANCE = [
+  'Working in the project:',
+  '- Inspect relevant files and project instructions using available search/read tools before proposing a fix. Ask for missing context only when tools cannot retrieve it.',
+  '- For implementation requests, apply the change when authorized tools are available; do not stop at a proposed diff. For questions or reviews, answer without changing files unless asked.',
+  '- Read the relevant region, then use edit_file with an exact, unique oldText/newText block. Use write_file for new files or explicitly authorized full rewrites. If an edit fails to match, re-read before retrying.',
+  '- Keep changes scoped to the request and existing conventions. Avoid unrelated refactors, dependency changes, or reverting user edits.',
+  '- Run targeted tests and the project lint/build as appropriate. Read failures, fix issues caused by the change, and repeat until verified, blocked, or cancelled. State clearly when checks could not run or failures are unrelated.',
+  '- Keep progress updates brief and tied to real milestones. Use { title, current, total, status, message } with a stable title, a positive total, and current between zero and total. If the tool is unavailable, use a short plain-language update instead.',
+  '- In the final reply, summarize what changed and what was verified; cite relevant paths and note remaining work. Do not dump raw tool output or claim success without evidence.'
+].join('\n');
+const EXTENSIVE_GUIDANCE = [
+  'Planning and verification:',
+  '- For multi-step work, outline a short plan and revise it when evidence changes. Use task tracking if available and useful; skip elaborate plans for simple requests.',
+  '- Inspect callers, nearby tests, and configuration to understand the behavior before editing. Prefer the smallest fix that addresses the root cause.',
+  '- Add or update regression tests for changed behavior and update related documentation. Test error paths and edge cases as well as the happy path.',
+  '- For UI changes, check narrow mobile widths first, touch targets, keyboard access, and loading/error states; then check larger screens.',
+  '- Parallelize independent reads or checks when useful. Keep dependent edits and commands ordered, and avoid concurrent writes to the same files.',
+  '- Review the final diff for accidental changes and sensitive data. Summarize relevant tool evidence without copying credentials, tokens, or unnecessary private data into the transcript.',
+  '',
+  'Workflow examples:',
+  '- Bug fix: reproduce or inspect the failing path, add a focused regression test, make the smallest correction, rerun checks, and report the results.',
+  '- Harmless ambiguity: follow a nearby naming convention and mention the assumption. Material ambiguity: ask which behavior is intended before changing it.',
+  '- Blocked check: if tests require an unavailable service, report which checks ran and which could not; do not describe the feature as fully verified or mark the task completed while required work remains.'
+].join('\n');
+const AVERAGE_GUIDANCE = CORE_GUIDANCE + '\n\n' + WORKFLOW_GUIDANCE;
+const PROFILES = Object.freeze({
+  'very-small': {
+    id: 'very-small',
+    label: 'Very small',
+    description: 'Core coding rules with on-demand tool schemas. Smallest prompt.',
+    summary: 'core rules + compact tools',
+    systemMessage: CORE_GUIDANCE
+  },
+  'average': {
+    id: 'average',
+    label: 'Average',
+    description: 'Core rules + inspect, edit, and verify workflow. The recommended default.',
+    summary: 'core rules + tool workflow',
+    systemMessage: AVERAGE_GUIDANCE
+  },
+  'extensive': {
+    id: 'extensive',
+    label: 'Extensive',
+    description: 'All Average guidance + planning, verification, and workflow examples.',
+    summary: 'core rules + workflow + examples',
+    systemMessage: AVERAGE_GUIDANCE + '\n\n' + EXTENSIVE_GUIDANCE
+  }
+});
+
+const DEFAULT_PROFILE = 'average';
+
+function isValidProfile(value) {
+  return typeof value === 'string' && Object.prototype.hasOwnProperty.call(PROFILES, value);
+}
+
+function profileSystemMessage(value) {
+  if (!isValidProfile(value)) return PROFILES[DEFAULT_PROFILE].systemMessage;
+  return PROFILES[value].systemMessage;
+}
+
+function describeProfile(value) {
+  if (!isValidProfile(value)) return null;
+  // Return a shallow copy so the caller cannot mutate the frozen module-level data.
+  return Object.assign({}, PROFILES[value]);
+}
+
+function listProfiles() {
+  return Object.keys(PROFILES).map(k => Object.assign({}, PROFILES[k]));
+}
+
+const DISCOVER_TOOL_NAME = 'discover_tool';
+
+function cloneJson(value) {
+  if (value === undefined) return undefined;
+  return JSON.parse(JSON.stringify(value));
+}
+
+function cloneToolSpec(spec) {
+  const fn = (spec && spec.function) || {};
+  return {
+    type: 'function',
+    function: {
+      name: fn.name,
+      description: fn.description,
+      parameters: cloneJson(fn.parameters)
+    }
+  };
+}
+
+function toolNameList(specs) {
+  return (Array.isArray(specs) ? specs : [])
+    .map(s => s && s.function && s.function.name)
+    .filter(Boolean);
+}
+
+function makeDiscoverToolSpec(specs) {
+  const names = toolNameList(specs);
+  const list = names.length ? names.join(', ') : '(none)';
+  return {
+    type: 'function',
+    function: {
+      name: DISCOVER_TOOL_NAME,
+      description: 'Discover the complete description and parameter schema for one available tool before calling it. Available tools: ' + list + '.',
+      parameters: {
+        type: 'object',
+        properties: {
+          toolName: {
+            type: 'string',
+            description: 'Name of the tool to expand.',
+            enum: names
+          }
+        },
+        required: ['toolName'],
+        additionalProperties: false
+      }
+    }
+  };
+}
+
+// reduceToolSpecs(specs, profileValue, opts) — shrink the tool declaration
+// advertised to the model according to the active prompt-size profile.
+// This is the core of the "three prompt-size profiles" feature
+// (.github/copilot-instructions.md §4): the profile controls HOW MUCH
+// of each tool is sent upstream, not just the system prompt text.
+//
+//   very-small : compact tool list, name + short description only (no
+//                parameter schemas), plus discover_tool for on-demand
+//                full-schema expansion. The list is FIXED for the whole
+//                turn: the same tools are advertised on the first request
+//                and on every tool-loop follow-up. Growing the list after
+//                a discover_tool call would change the Anthropic cached
+//                prefix (system + tools) between requests, so the warm
+//                cache would be invalidated on every round and caching
+//                would never engage.
+//   average    : full tool list, name + full description + parameters
+//                (the compact-but-complete default).
+//   extensive  : same as average (full), kept separate so the extensive
+//                system prompt's best-practice guidance is what makes it
+//                "extensive"; the tools themselves are already complete.
+//
+// `specs` is an array of OpenAI-shape tool specs
+// ({ type:'function', function:{ name, description, parameters } }).
+// Returns a NEW array; the input is never mutated. Unknown profiles
+// fall through to the full list.
+function reduceToolSpecs(specs, profileValue, opts) {
+  if (!Array.isArray(specs) || !specs.length) return [];
+  const profile = isValidProfile(profileValue) ? profileValue : DEFAULT_PROFILE;
+  if (profile !== 'very-small') {
+    // average + extensive: full specs, defensively copied.
+    return specs.map(cloneToolSpec);
+  }
+  // very-small: discover_tool + one compact entry per tool, stable for
+  // the whole turn. Compact entries keep the token budget low (the
+  // profile's whole point) while the byte-stable list keeps the
+  // Anthropic cache prefix identical across tool-loop requests.
+  const out = [makeDiscoverToolSpec(specs)];
+  for (const spec of specs) {
+    const fn = (spec && spec.function) || {};
+    if (!fn.name) continue;
+    out.push({
+      type: 'function',
+      function: {
+        name: fn.name,
+        description: typeof fn.description === 'string' ? fn.description : '',
+        // No `parameters` block: the model gets the tool's shape via
+        // discover_tool if it needs it. Omitting it here is what keeps
+        // very-small's footprint small AND the prefix stable.
+      }
+    });
+  }
+  return out;
+}
+
+// resolveProfile({ chat, projectDir }) — pick the profile that applies
+// to a chat right now. Resolution: chat.promptSize (if valid) -> the
+// project's resolved promptSize (defaults -> app -> project, per
+// decisions §2) -> 'average'. The function never throws; an unknown
+// value falls through to the next layer so a stale or hand-edited
+// project file still gets a sensible prompt.
+function resolveProfile(opts) {
+  const chat = opts && opts.chat;
+  const projectDir = opts && opts.projectDir;
+  let chosen = null;
+  if (chat && isValidProfile(chat.promptSize)) chosen = chat.promptSize;
+  if (!chosen && projectDir) {
+    try {
+      const settings = require('./settings.js');
+      const resolved = settings.getResolved(projectDir);
+      if (isValidProfile(resolved && resolved.promptSize)) chosen = resolved.promptSize;
+    } catch { /* fall through to default */ }
+  }
+  if (!chosen) chosen = DEFAULT_PROFILE;
+  return Object.assign({}, PROFILES[chosen], { systemMessage: PROFILES[chosen].systemMessage });
+}
+
+module.exports = {
+  PROFILES,
+  DEFAULT_PROFILE,
+  isValidProfile,
+  profileSystemMessage,
+  describeProfile,
+  listProfiles,
+  resolveProfile,
+  reduceToolSpecs,
+  DISCOVER_TOOL_NAME,
+  makeDiscoverToolSpec
+};