atris 2.6.0 → 2.6.2

package/lib/section-merge.js

@@ -0,0 +1,196 @@
+/**
+ * Section-level three-way merge for structured markdown files.
+ *
+ * Parses markdown into sections (split on ## headers + YAML frontmatter).
+ * Merges non-conflicting section changes. Flags same-section conflicts.
+ *
+ * This is what makes us better than git for context files.
+ * Git merges by line. We merge by section.
+ */
+
+/**
+ * Parse a markdown document into sections.
+ * Returns: { __frontmatter__: string, __header__: string, sections: [{name, content}] }
+ */
+function parseSections(content) {
+  if (!content) return { frontmatter: '', header: '', sections: [] };
+
+  const lines = content.split('\n');
+  let frontmatter = '';
+  let header = '';
+  const sections = [];
+  let current = null;
+  let inFrontmatter = false;
+  let frontmatterDone = false;
+  let headerLines = [];
+
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+
+    // YAML frontmatter
+    if (i === 0 && line.trim() === '---') {
+      inFrontmatter = true;
+      headerLines.push(line);
+      continue;
+    }
+    if (inFrontmatter) {
+      headerLines.push(line);
+      if (line.trim() === '---') {
+        inFrontmatter = false;
+        frontmatterDone = true;
+        frontmatter = headerLines.join('\n');
+        headerLines = [];
+      }
+      continue;
+    }
+
+    // Section headers
+    if (line.startsWith('## ')) {
+      // Save previous section or header
+      if (current) {
+        sections.push(current);
+      } else if (headerLines.length > 0) {
+        header = headerLines.join('\n');
+      }
+      current = { name: line.substring(3).trim(), content: line };
+      continue;
+    }
+
+    // Content belongs to current section or header
+    if (current) {
+      current.content += '\n' + line;
+    } else {
+      headerLines.push(line);
+    }
+  }
+
+  // Save last section or header
+  if (current) {
+    sections.push(current);
+  } else if (headerLines.length > 0 && !header) {
+    header = headerLines.join('\n');
+  }
+
+  return { frontmatter, header, sections };
+}
+
+/**
+ * Reconstruct a markdown document from parsed sections.
+ */
+function reconstructDocument(parsed) {
+  const parts = [];
+  if (parsed.frontmatter) parts.push(parsed.frontmatter);
+  if (parsed.header) parts.push(parsed.header);
+  for (const section of parsed.sections) {
+    parts.push(section.content);
+  }
+  return parts.join('\n');
+}
+
+/**
+ * Three-way section merge.
+ *
+ * @param {string} base - Common ancestor content
+ * @param {string} local - Your version
+ * @param {string} remote - Their version
+ * @returns {{ merged: string|null, conflicts: [{section, local, remote}] }}
+ *
+ * If merged is non-null, the merge succeeded (conflicts array is empty).
+ * If merged is null, there are conflicts that need manual resolution.
+ */
+function sectionMerge(base, local, remote) {
+  const baseParsed = parseSections(base);
+  const localParsed = parseSections(local);
+  const remoteParsed = parseSections(remote);
+
+  const conflicts = [];
+
+  // Merge frontmatter (field-by-field if both changed, otherwise take the changed one)
+  let mergedFrontmatter = baseParsed.frontmatter;
+  if (localParsed.frontmatter !== baseParsed.frontmatter && remoteParsed.frontmatter === baseParsed.frontmatter) {
+    mergedFrontmatter = localParsed.frontmatter;
+  } else if (remoteParsed.frontmatter !== baseParsed.frontmatter && localParsed.frontmatter === baseParsed.frontmatter) {
+    mergedFrontmatter = remoteParsed.frontmatter;
+  } else if (localParsed.frontmatter !== remoteParsed.frontmatter && localParsed.frontmatter !== baseParsed.frontmatter) {
+    conflicts.push({ section: 'frontmatter', local: localParsed.frontmatter, remote: remoteParsed.frontmatter });
+  }
+
+  // Merge header
+  let mergedHeader = baseParsed.header;
+  if (localParsed.header !== baseParsed.header && remoteParsed.header === baseParsed.header) {
+    mergedHeader = localParsed.header;
+  } else if (remoteParsed.header !== baseParsed.header && localParsed.header === baseParsed.header) {
+    mergedHeader = remoteParsed.header;
+  } else if (localParsed.header !== remoteParsed.header && localParsed.header !== baseParsed.header) {
+    conflicts.push({ section: 'header', local: localParsed.header, remote: remoteParsed.header });
+  }
+
+  // Build section maps
+  const baseMap = {};
+  for (const s of baseParsed.sections) baseMap[s.name] = s.content;
+  const localMap = {};
+  for (const s of localParsed.sections) localMap[s.name] = s.content;
+  const remoteMap = {};
+  for (const s of remoteParsed.sections) remoteMap[s.name] = s.content;
+
+  // Get all section names preserving order (base order, then new sections)
+  const allNames = [];
+  const seen = new Set();
+  for (const s of baseParsed.sections) { allNames.push(s.name); seen.add(s.name); }
+  for (const s of localParsed.sections) { if (!seen.has(s.name)) { allNames.push(s.name); seen.add(s.name); } }
+  for (const s of remoteParsed.sections) { if (!seen.has(s.name)) { allNames.push(s.name); seen.add(s.name); } }
+
+  // Merge each section
+  const mergedSections = [];
+  for (const name of allNames) {
+    const b = baseMap[name] || null;
+    const l = localMap[name] || null;
+    const r = remoteMap[name] || null;
+
+    if (l === r) {
+      // Both same — take either (or null = both deleted)
+      if (l !== null) mergedSections.push({ name, content: l });
+      continue;
+    }
+
+    if (b === null) {
+      // New section — exists in one or both
+      if (l && !r) { mergedSections.push({ name, content: l }); continue; }
+      if (r && !l) { mergedSections.push({ name, content: r }); continue; }
+      // Both added same-named section with different content
+      conflicts.push({ section: name, local: l, remote: r });
+      mergedSections.push({ name, content: l }); // default to local
+      continue;
+    }
+
+    const localChanged = l !== b;
+    const remoteChanged = r !== b;
+
+    if (!localChanged && remoteChanged) {
+      if (r !== null) mergedSections.push({ name, content: r });
+      // else: remote deleted it, local didn't change → accept deletion
+    } else if (localChanged && !remoteChanged) {
+      if (l !== null) mergedSections.push({ name, content: l });
+      // else: local deleted it, remote didn't change → accept deletion
+    } else {
+      // Both changed the same section → conflict
+      conflicts.push({ section: name, local: l, remote: r });
+      if (l !== null) mergedSections.push({ name, content: l }); // default to local
+    }
+  }
+
+  if (conflicts.length > 0) {
+    return { merged: null, conflicts };
+  }
+
+  // Reconstruct
+  const merged = reconstructDocument({
+    frontmatter: mergedFrontmatter,
+    header: mergedHeader,
+    sections: mergedSections,
+  });
+
+  return { merged, conflicts: [] };
+}
+
+module.exports = { parseSections, reconstructDocument, sectionMerge };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "atris",
-  "version": "2.6.0",
+  "version": "2.6.2",
   "description": "atrisDev (atris dev) - CLI for AI coding agents. Works with Claude Code, Cursor, Windsurf. Make any codebase AI-navigable.",
   "main": "bin/atris.js",
   "bin": {
@@ -12,7 +12,6 @@
     "utils/",
     "lib/",
     "README.md",
-    "AGENT.md",
     "AGENTS.md",
     "atris.md",
     "GETTING_STARTED.md",
@@ -20,8 +19,14 @@
     "atris/atrisDev.md",
     "atris/CLAUDE.md",
     "atris/GEMINI.md",
-    "atris/team/",
-    "atris/experiments/",
+    "atris/GETTING_STARTED.md",
+    "atris/team/navigator/MEMBER.md",
+    "atris/team/executor/MEMBER.md",
+    "atris/team/validator/MEMBER.md",
+    "atris/team/brainstormer/MEMBER.md",
+    "atris/team/launcher/MEMBER.md",
+    "atris/team/researcher/MEMBER.md",
+    "atris/team/_template/MEMBER.md",
     "atris/features/_templates/",
     "atris/policies/",
     "atris/skills/"

package/utils/api.js

@@ -41,7 +41,7 @@ function httpRequest(urlString, options) {
     const parsed = new URL(urlString);
     const isHttps = parsed.protocol === 'https:';
     const transport = isHttps ? https : http;
-    const timeoutMs = typeof options.timeoutMs === 'number' ? options.timeoutMs : 10000;
+    const timeoutMs = typeof options.timeoutMs === 'number' ? options.timeoutMs : 30000;
 
     const requestOptions = {
       method: options.method || 'GET',
@@ -52,6 +52,13 @@ function httpRequest(urlString, options) {
     };
 
     const req = transport.request(requestOptions, (res) => {
+      // Follow redirects (301, 302, 307, 308)
+      if ([301, 302, 307, 308].includes(res.statusCode) && res.headers.location) {
+        const redirectUrl = new URL(res.headers.location, urlString).toString();
+        resolve(httpRequest(redirectUrl, options));
+        return;
+      }
+
       const chunks = [];
       res.on('data', (chunk) => chunks.push(chunk));
       res.on('end', () => {
@@ -111,6 +118,7 @@ async function apiRequestJson(pathname, options = {}) {
       method: options.method || 'GET',
       headers,
       body: bodyPayload,
+      timeoutMs: options.timeoutMs,
     });
 
     const text = result.body.toString('utf8');

package/utils/update-check.js

@@ -4,8 +4,9 @@ const path = require('path');
 const os = require('os');
 
 const PACKAGE_NAME = 'atris';
-const CHECK_INTERVAL_MS = 24 * 60 * 60 * 1000; // 24 hours
-const CACHE_FILE = path.join(os.homedir(), '.atris-update-check.json');
+const CHECK_INTERVAL_MS = 60 * 60 * 1000; // 1 hour
+const ATRIS_DIR = path.join(os.homedir(), '.atris');
+const CACHE_FILE = path.join(ATRIS_DIR, '.update-check');
 
 function getInstalledVersion() {
   try {
@@ -34,6 +35,10 @@ function getCacheData() {
 
 function saveCacheData(latestVersion) {
   try {
+    // Ensure ~/.atris/ exists
+    if (!fs.existsSync(ATRIS_DIR)) {
+      fs.mkdirSync(ATRIS_DIR, { recursive: true });
+    }
     const data = {
       lastCheck: new Date().toISOString(),
       latestVersion: latestVersion,
@@ -164,15 +169,10 @@ async function checkForUpdates(force = false) {
 function showUpdateNotification(updateInfo) {
   if (!updateInfo || !updateInfo.needsUpdate) return;
 
-  console.log('');
-  console.log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
-  console.log(`📦 Update available: ${updateInfo.installed} → ${updateInfo.latest}`);
-  console.log(`   Run: npm update -g atris`);
-  if (updateInfo.fromCache) {
-    console.log(`   (checking npm registry...)`);
-  }
-  console.log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
-  console.log('');
+  // Single yellow warning line — non-intrusive
+  const yellow = '\x1b[33m';
+  const reset = '\x1b[0m';
+  console.log(`${yellow}Update available: ${updateInfo.installed} → ${updateInfo.latest}. Run: npm install -g atris${reset}`);
 }
 
 function autoUpdate(updateInfo) {

package/AGENT.md

@@ -1,35 +0,0 @@
-# AGENT.md
-
-This file provides guidance to any coding agent (Claude Code, Cursor, Windsurf, etc) when working with code in this repository.
-
-## Using Atris (If atris/ folder exists)
-
-**You are in an Atris-managed project.**
-
-**FIRST:** Read `atris/PERSONA.md` and adopt that personality.
-
-**Then follow this workflow:**
-1. **Execute first, research only if needed** — Run commands/tools directly. Don't search docs first—see what happens, then investigate if it fails. Saves context.
-2. **Before any change:** Read `atris/MAP.md` to find relevant files/components
-3. **When starting a task:** Check `atris/TODO.md` for existing tasks or add new one
-4. **After completing task:** Delete task from TODO.md
-5. **If architecture changes:** Update `atris/MAP.md` with new structure
-6. **Follow agent workflow:** navigator (find) → executor (build) → validator (verify)
-
-**Key files:**
-- `atris/PERSONA.md` - How to communicate and work (READ THIS FIRST)
-- `atris/MAP.md` - Navigation guide (where is X?)
-- `atris/TODO.md` - Active tasks (delete when done)
-- `atris/team/*.md` - Agent specs for reference
-
----
-
-**Quick Start:**
-1. Read PERSONA.md
-2. Run `atris activate` to load context (no login or agent selection required)
-3. Check TODO.md for current work
-4. Use `atris visualize` to see plans before building
-5. Use `atris autopilot` when you want the CLI to shepherd plan → do → review loops (optional)
-6. Use `atris brainstorm` to generate a concise conversation starter before handing ideas to coding agents (optional)
-
-Need to chat with Atris cloud agents? Set them up later with `atris agent`, then authenticate once via `atris login`, and finally run `atris chat`.

package/atris/experiments/README.md

@@ -1,118 +0,0 @@
-# experiments
-
-Karpathy-style experiment framework for Atris workspaces.
-
-This folder defines the schema, validation rules, and benchmark harness for self-improvement loops.
-Live experiment packs belong directly inside `atris/experiments/`.
-
-## What This Is
-
-An experiment is not "the agent rewrote its prompt and said it improved."
-
-An experiment is:
-
-1. one bounded target
-2. one external metric
-3. one keep/revert loop
-4. one append-only log
-
-If the metric goes up, keep the change.
-If it does not, revert it.
-
-## Schema
-
-```text
-atris/experiments/
-├── README.md
-├── validate.py
-├── benchmark_validate.py
-├── benchmark_runtime.py
-├── _template/           # packaged scaffolds
-├── _examples/           # packaged smoke examples
-├── _fixtures/           # validator benchmark cases
-└── <experiment-slug>/
-    ├── program.md
-    ├── measure.py
-    ├── loop.py
-    ├── results.tsv
-    ├── reset.py            # preferred
-    ├── proposals/          # optional
-    └── <bounded-target>    # candidate.py, system_prompt.txt, etc.
-```
-
-## Rules
-
-1. One bounded mutation target per experiment.
-2. `measure.py` must use an external metric the agent cannot fake.
-3. `loop.py` must keep only improvements and revert regressions.
-4. `program.md` stays short and task-specific.
-5. `results.tsv` stays append-only.
-
-## Repo Contents
-
-- `_template/pack/` - starter files for a new experiment
-- `validate.py` - structural and bloat checks
-- `benchmark_validate.py` - validator benchmark on fixed good/bad fixtures
-- `benchmark_runtime.py` - runtime benchmark on packaged example packs
-- `_examples/` - tiny reference implementation
-
-## Example
-
-Start with the smallest honest pack:
-
-```text
-_examples/smoke-keep-revert/
-├── candidate.py
-├── measure.py
-├── loop.py
-├── reset.py
-├── results.tsv
-└── proposals/
-    ├── bad_patch.py
-    └── fix_patch.py
-```
-
-What it does:
-
-- `candidate.py` starts broken on purpose
-- `measure.py` scores it on a fixed word-count test
-- `bad_patch.py` makes it worse
-- `fix_patch.py` actually fixes it
-- `loop.py` keeps only the fix
-
-Run it:
-
-```bash
-python _examples/smoke-keep-revert/reset.py
-python _examples/smoke-keep-revert/loop.py \
-  --proposal _examples/smoke-keep-revert/proposals/bad_patch.py \
-  --proposal _examples/smoke-keep-revert/proposals/fix_patch.py
-```
-
-Visual:
-
-```text
-broken target
-   ↓
-score = 0.2
-   ↓
-bad patch
-   ↓
-score = 0.0
-   ↓
-REVERT
-   ↓
-good patch
-   ↓
-score = 1.0
-   ↓
-KEEP
-```
-
-## Commands
-
-```bash
-python validate.py .
-python benchmark_validate.py
-python benchmark_runtime.py
-```

package/atris/experiments/_examples/smoke-keep-revert/README.md

@@ -1,45 +0,0 @@
-# smoke-keep-revert
-
-Smallest honest example of the framework.
-
-![Smoke Keep/Revert Flow](./visual.svg)
-
-## Files
-
-```text
-candidate.py   -> bounded target
-measure.py     -> hard score
-loop.py        -> keep/revert engine
-reset.py       -> restore baseline
-results.tsv    -> trial log
-proposals/     -> bad patch + good patch
-```
-
-## Flow
-
-```text
-candidate.py is wrong
-   ↓
-measure.py scores baseline
-   ↓
-loop.py applies bad_patch.py
-   ↓
-score does not improve
-   ↓
-loop.py reverts the change
-   ↓
-loop.py applies fix_patch.py
-   ↓
-score improves
-   ↓
-loop.py keeps the change
-```
-
-## Run
-
-```bash
-python reset.py
-python loop.py \
-  --proposal proposals/bad_patch.py \
-  --proposal proposals/fix_patch.py
-```

package/atris/experiments/_examples/smoke-keep-revert/candidate.py

@@ -1,8 +0,0 @@
-"""Bounded mutation target for the smoke experiment."""
-
-
-def count_words(text: str) -> int:
-    cleaned = text.strip()
-    if not cleaned:
-        return 0
-    return len(cleaned.split())

package/atris/experiments/_examples/smoke-keep-revert/loop.py

@@ -1,129 +0,0 @@
-"""Shared keep/revert loop for a bounded local experiment."""
-
-from __future__ import annotations
-
-import argparse
-import csv
-import json
-import os
-from pathlib import Path
-import shutil
-import subprocess
-import sys
-from datetime import datetime, timezone
-
-
-EXPERIMENT_DIR = Path(__file__).resolve().parent
-DEFAULT_TARGET = EXPERIMENT_DIR / "candidate.py"
-DEFAULT_MEASURE = EXPERIMENT_DIR / "measure.py"
-DEFAULT_RESULTS = EXPERIMENT_DIR / "results.tsv"
-
-
-def run_measure(measure_path: Path) -> dict:
-    proc = subprocess.run(
-        [sys.executable, str(measure_path)],
-        cwd=str(EXPERIMENT_DIR),
-        capture_output=True,
-        text=True,
-        check=True,
-    )
-    return json.loads(proc.stdout.strip())
-
-
-def append_result(results_path: Path, row: dict) -> None:
-    write_header = not results_path.exists() or results_path.stat().st_size == 0
-    with results_path.open("a", newline="", encoding="utf-8") as handle:
-        writer = csv.DictWriter(
-            handle,
-            fieldnames=[
-                "timestamp",
-                "trial",
-                "status",
-                "old_score",
-                "new_score",
-                "proposal",
-                "description",
-            ],
-            delimiter="\t",
-        )
-        if write_header:
-            writer.writeheader()
-        writer.writerow(row)
-
-
-def restore_backup(backup_path: Path, target_path: Path) -> None:
-    shutil.copy2(backup_path, target_path)
-    backup_path.unlink(missing_ok=True)
-
-
-def main() -> int:
-    parser = argparse.ArgumentParser(description="Run a bounded keep/revert experiment.")
-    parser.add_argument("--proposal", action="append", default=[])
-    args = parser.parse_args()
-
-    target_path = DEFAULT_TARGET.resolve()
-    measure_path = DEFAULT_MEASURE.resolve()
-    results_path = DEFAULT_RESULTS.resolve()
-
-    baseline = run_measure(measure_path)
-    current_score = float(baseline["score"])
-    print(f"BASELINE {current_score:.4f}")
-
-    for trial_index, proposal in enumerate(args.proposal, start=1):
-        proposal_path = Path(proposal).resolve()
-        backup_path = target_path.with_suffix(target_path.suffix + f".trial{trial_index}.bak")
-        shutil.copy2(target_path, backup_path)
-
-        status = "error"
-        old_score = current_score
-        new_score = current_score
-        description = ""
-
-        try:
-            proc = subprocess.run(
-                [sys.executable, str(proposal_path)],
-                cwd=str(EXPERIMENT_DIR),
-                capture_output=True,
-                text=True,
-                check=True,
-                env={**os.environ, "EXPERIMENT_TARGET": str(target_path)},
-            )
-            if proc.stdout.strip():
-                description = proc.stdout.strip().splitlines()[-1][:200]
-
-            measured = run_measure(measure_path)
-            new_score = float(measured["score"])
-            if new_score > current_score:
-                status = "kept"
-                current_score = new_score
-                backup_path.unlink(missing_ok=True)
-            else:
-                status = "reverted"
-                restore_backup(backup_path, target_path)
-        except subprocess.CalledProcessError as exc:
-            restore_backup(backup_path, target_path)
-            stderr = (exc.stderr or exc.stdout or "").strip()
-            description = (stderr.splitlines()[-1] if stderr else "proposal failed")[:200]
-            status = "error"
-
-        append_result(
-            results_path,
-            {
-                "timestamp": datetime.now(timezone.utc).isoformat(),
-                "trial": trial_index,
-                "status": status,
-                "old_score": f"{old_score:.4f}",
-                "new_score": f"{new_score:.4f}",
-                "proposal": proposal_path.name,
-                "description": description,
-            },
-        )
-        print(f"TRIAL {trial_index} {status.upper()} score={new_score:.4f} proposal={proposal_path.name}")
-
-    final_measure = run_measure(measure_path)
-    print(f"FINAL {final_measure['score']:.4f}")
-    return 0
-
-
-if __name__ == "__main__":
-    raise SystemExit(main())

package/atris/experiments/_examples/smoke-keep-revert/measure.py

@@ -1,47 +0,0 @@
-"""Objective metric for the smoke keep/revert example."""
-
-from __future__ import annotations
-
-import json
-from pathlib import Path
-import sys
-
-
-EXPERIMENT_DIR = Path(__file__).resolve().parent
-if str(EXPERIMENT_DIR) not in sys.path:
-    sys.path.insert(0, str(EXPERIMENT_DIR))
-
-from candidate import count_words
-
-
-CASES = [
-    ("", 0),
-    ("one", 1),
-    ("two words", 2),
-    ("  three   spaced   words ", 3),
-    ("punctuation, still counts", 3),
-]
-
-
-def main() -> int:
-    passed = 0
-
-    for text, expected in CASES:
-        actual = count_words(text)
-        if actual == expected:
-            passed += 1
-
-    total = len(CASES)
-    score = passed / total if total else 0.0
-    payload = {
-        "score": round(score, 4),
-        "passed": passed,
-        "total": total,
-        "status": "pass" if passed == total else "fail",
-    }
-    print(json.dumps(payload))
-    return 0
-
-
-if __name__ == "__main__":
-    raise SystemExit(main())

package/atris/experiments/_examples/smoke-keep-revert/program.md

@@ -1,3 +0,0 @@
-# Program
-
-Prove the keep/revert loop in the smallest honest way.