phewsh 0.15.54 → 0.15.56

package/lib/md.js

@@ -33,6 +33,43 @@ function inlineMd(t, base = '') {
       (_, x, u) => `${A.uline}${A.teal}${x}${A.reset}${base} ${A.dim}${A.slate}(${u})${A.reset}${base}`);
 }
 
+// Soft-wrap a rendered line at word boundaries to the terminal width — this is
+// what replaces the terminal's mid-word hard wrap (CSS `text-wrap: pretty`, in
+// spirit). We never break inside a word. `base` is the block's colour SGR,
+// re-emitted at the start of each continuation line so colour survives the
+// break; `hang` is the continuation indent (hanging indent under list/quote
+// markers). No-op when width is unknown (piped output) so redirected text and
+// tests stay raw.
+const ANSI = /\x1b\[[0-9;]*m/g;
+const vis = (s) => s.replace(ANSI, '').length;
+
+function softWrap(s, base = '', hang) {
+  const width = process.stdout.columns;
+  if (!width || width < 24 || vis(s) <= width) return s;
+  const lead = s.match(/^ */)[0].length;
+  const indent = hang == null ? lead : hang;
+  const words = s.slice(lead).split(/ +/);
+  const pad = ' '.repeat(indent);
+  const out = [];
+  let cur = ' '.repeat(lead);
+  let len = lead;
+  let started = false;
+  for (const word of words) {
+    const wl = vis(word);
+    if (started && len + 1 + wl > width) {
+      out.push(cur + A.reset);
+      cur = base + pad + word;
+      len = indent + wl;
+    } else {
+      cur += (started ? ' ' : '') + word;
+      len += (started ? 1 : 0) + wl;
+      started = true;
+    }
+  }
+  out.push(cur);
+  return out.join('\n');
+}
+
 // Render one complete line, mutating `state` for block-level context.
 // Body text keeps the default terminal foreground (bright) — only structural
 // elements get colour, so a reply reads as a reply, not as dimmed UI chrome.
@@ -47,12 +84,12 @@ function renderLine(line, state = {}) {
   }
   if (/^#{1,2}\s/.test(line)) return `\n${A.bold}${A.teal}${inlineMd(line.replace(/^#+\s*/, ''), A.teal)}${A.reset}`;
   if (/^#{3,}\s/.test(line)) return `${A.cream}${inlineMd(line.replace(/^#+\s*/, ''), A.cream)}${A.reset}`;
-  if (/^\s*[-*]\s/.test(line)) return `  ${A.teal}·${A.reset} ${A.sage}${inlineMd(line.replace(/^\s*[-*]\s*/, ''), A.sage)}${A.reset}`;
-  if (/^\s*\d+\.\s/.test(line)) return `  ${A.sage}${inlineMd(line.trim(), A.sage)}${A.reset}`;
-  if (/^\s*>\s?/.test(line)) return `  ${A.slate}${A.ital}${inlineMd(line.replace(/^\s*>\s?/, ''), A.slate)}${A.italOff}${A.reset}`;
+  if (/^\s*[-*]\s/.test(line)) return softWrap(`  ${A.teal}·${A.reset} ${A.sage}${inlineMd(line.replace(/^\s*[-*]\s*/, ''), A.sage)}${A.reset}`, A.sage, 4);
+  if (/^\s*\d+\.\s/.test(line)) return softWrap(`  ${A.sage}${inlineMd(line.trim(), A.sage)}${A.reset}`, A.sage, 5);
+  if (/^\s*>\s?/.test(line)) return softWrap(`  ${A.slate}${A.ital}${inlineMd(line.replace(/^\s*>\s?/, ''), A.slate)}${A.italOff}${A.reset}`, A.slate, 4);
   if (/^---+\s*$/.test(line)) return `  ${A.slate}${'─'.repeat(40)}${A.reset}`;
   if (line.trim() === '') return '';
-  return inlineMd(line, ''); // body: default foreground, inline styling only
+  return softWrap(inlineMd(line, ''), '', 0); // body: default foreground, inline styling only
 }
 
 // Line-buffered streaming renderer. Feed raw token text via push(); each time a

package/lib/selfheal.js

@@ -108,7 +108,9 @@ function upsertBlock(filePath, core, footer, fileLabel, headerText) {
       const expectedSource = footerSource(footer);
       if (m && coreOf(m[1]) === coreOf(core) &&
           (!expectedSource || footerSource(m[1]) === expectedSource)) return false;
-      const next = existing.replace(re, wrapped);
+      // A replacement function keeps canonical text such as "$10" from being
+      // interpreted as a regex capture reference and duplicating old content.
+      const next = existing.replace(re, () => wrapped);
       fs.writeFileSync(filePath, next);
     } else if (existing) {
       fs.writeFileSync(filePath, existing.replace(/\s*$/, '') + '\n\n' + wrapped + '\n');
@@ -153,7 +155,17 @@ function buildContextCore(cwd = process.cwd()) {
   let output;
   try {
     if (cwd !== prev) process.chdir(cwd);
-    output = sequence({ target: 'claude-md', write: false }).output;
+    output = sequence({
+      target: 'claude-md',
+      sources: ['intent'],
+      sourceNames: ['vision.md', 'project.json', 'status.md', 'next.md', 'next.json'],
+      excludeChunkSources: [
+        '.intent/project.json:actions',
+        '.intent/project.json:responsibilities',
+        '.intent/project.json:success',
+      ],
+      write: false,
+    }).output;
   } finally {
     if (cwd !== prev) { try { process.chdir(prev); } catch { /* best-effort */ } }
   }

package/lib/sequencer/index.js

@@ -33,6 +33,8 @@ const emitters = {
  * @param {string} options.target - Output format: 'claude-md' | 'stdout' | 'json'
  * @param {string} options.budget - Token budget: 'minimal' | 'standard' | 'full' | 'unlimited'
  * @param {string[]} options.sources - Limit to specific source types (null = all)
+ * @param {string[]} options.sourceNames - Limit to specific discovered filenames (null = all)
+ * @param {string[]} options.excludeChunkSources - Omit exact parsed chunk sources
  * @param {boolean} options.explain - Show full ranking breakdown
  * @param {boolean} options.write - Write to file (for claude-md target)
  * @param {string} options.cwd - Working directory
@@ -43,6 +45,8 @@ function sequence(options = {}) {
     target = 'claude-md',
     budget = 'standard',
     sources: sourceFilter = null,
+    sourceNames = null,
+    excludeChunkSources = null,
     explain = false,
     write = false,
     includeGlobal = false,
@@ -73,6 +77,9 @@ function sequence(options = {}) {
       sourceFilter.some(f => s.type === f || s.type.startsWith(f))
     );
   }
+  if (sourceNames && sourceNames.length > 0) {
+    sources = sources.filter(source => sourceNames.includes(source.name));
+  }
 
   // 2. Parse all sources into chunks
   let chunks = [];
@@ -83,6 +90,9 @@ function sequence(options = {}) {
     const parsed = parser.parse(source);
     chunks.push(...parsed);
   }
+  if (excludeChunkSources && excludeChunkSources.length > 0) {
+    chunks = chunks.filter(chunk => !excludeChunkSources.includes(chunk.source));
+  }
 
   // 3. Rank all chunks
   chunks = rank(chunks);

package/lib/sequencer/parsers/intent.js

@@ -75,12 +75,19 @@ function parseStatus(filePath) {
   const { meta, body } = parseFrontmatter(content);
   const mtime = fs.statSync(filePath).mtime.toISOString();
   const timestamp = meta.updated || meta.created || mtime;
+  // Harness projections need the curated current state, not the full journal.
+  // Truncate before ranking/compression so a long history cannot crowd the
+  // structured Next item and its accepted success criteria out of the budget.
+  const lines = body.split('\n');
+  let cut = lines.findIndex(line => /^---+\s*$/.test(line));
+  if (cut < 0 || cut > 24) cut = 24;
+  const current = lines.slice(0, cut).join('\n').trim();
 
   return [{
     source: '.intent/status.md',
     sourceType: 'intent',
     kind: 'state',
-    content: body.trim(),
+    content: current,
     timestamp,
     metadata: { frontmatter: meta },
   }];
@@ -91,12 +98,19 @@ function parseNext(filePath) {
   const { meta, body } = parseFrontmatter(content);
   const mtime = fs.statSync(filePath).mtime.toISOString();
   const timestamp = meta.updated || meta.created || mtime;
+  const lines = body.split('\n');
+  const sectionIndexes = lines
+    .map((line, index) => (/^##\s+/.test(line) ? index : -1))
+    .filter(index => index >= 0);
+  const cut = sectionIndexes.length > 1
+    ? sectionIndexes[1]
+    : Math.min(lines.length, 24);
 
   return [{
     source: '.intent/next.md',
     sourceType: 'intent',
     kind: 'state',
-    content: body.trim(),
+    content: lines.slice(0, cut).join('\n').trim(),
     timestamp,
     metadata: { frontmatter: meta },
   }];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "phewsh",
-  "version": "0.15.54",
+  "version": "0.15.56",
   "description": "Turn intent into action. Structure your thinking, execute your next step.",
   "bin": {
     "phewsh": "bin/phewsh.js"