copperhead 0.8.0 → 0.9.0

package/src/kicad/sexp.ts

@@ -224,15 +224,33 @@ function symbolsOf(sheet: ParsedSheet): { node: SexpNode[]; sym: SchematicSymbol
   return out;
 }
 
-const isPowerSymbol = (libId: string): boolean => libId.startsWith('power:');
+function collectPowerSymbols(sheets: ParsedSheet[]): Set<string> {
+  const set = new Set<string>();
+  for (const sheet of sheets) {
+    const libs = child(sheet.root, 'lib_symbols');
+    if (!libs) continue;
+    for (const sym of children(libs, 'symbol')) {
+      const name = atomAt(sym, 1);
+      const p = child(sym, 'power');
+      if (name && p !== undefined && atomAt(p, 1) !== 'no') {
+        set.add(name);
+      }
+    }
+  }
+  return set;
+}
+
+const isPowerSymbol = (libId: string, powerSyms: Set<string>): boolean =>
+  libId.startsWith('power:') || powerSyms.has(libId);
 
 /** One row per real component (power symbols excluded), across all sheets. */
 export async function listSymbols(rootSch: string): Promise<SchematicSymbol[]> {
   const sheets = await loadSheets(rootSch);
+  const powerSyms = collectPowerSymbols(sheets);
   const out: SchematicSymbol[] = [];
   for (const sheet of sheets) {
     for (const { sym } of symbolsOf(sheet)) {
-      if (!isPowerSymbol(sym.libId)) out.push(sym);
+      if (!isPowerSymbol(sym.libId, powerSyms)) out.push(sym);
     }
   }
   return out.sort((a, b) => a.ref.localeCompare(b.ref, undefined, { numeric: true }));
@@ -241,6 +259,7 @@ export async function listSymbols(rootSch: string): Promise<SchematicSymbol[]> {
 /** All net names visible via labels and power symbols, across all sheets. */
 export async function listNets(rootSch: string): Promise<string[]> {
   const sheets = await loadSheets(rootSch);
+  const powerSyms = collectPowerSymbols(sheets);
   const names = new Set<string>();
   for (const sheet of sheets) {
     for (const kind of ['label', 'global_label', 'hierarchical_label']) {
@@ -250,7 +269,7 @@ export async function listNets(rootSch: string): Promise<string[]> {
       }
     }
     for (const { sym } of symbolsOf(sheet)) {
-      if (isPowerSymbol(sym.libId)) names.add(sym.value);
+      if (isPowerSymbol(sym.libId, powerSyms)) names.add(sym.value);
     }
   }
   return [...names].sort();
@@ -271,6 +290,7 @@ export interface PinNet {
  */
 export async function pinNets(rootSch: string): Promise<PinNet[]> {
   const sheets = await loadSheets(rootSch);
+  const powerSyms = collectPowerSymbols(sheets);
   const out: PinNet[] = [];
   for (const sheet of sheets) {
     const pinDefs = libPinDefs(sheet.root);
@@ -304,7 +324,7 @@ export async function pinNets(rootSch: string): Promise<PinNet[]> {
         const abs = pinAbsolute(sym.at, mirror, pin);
         const k = key(abs.x, abs.y);
         uf.find(k);
-        if (isPowerSymbol(sym.libId)) {
+        if (isPowerSymbol(sym.libId, powerSyms)) {
           netNameAt.set(k, sym.value);
         } else {
           symPins.push({ sym, pin, k });

package/src/memory/bom-table.ts

@@ -9,6 +9,25 @@ export interface TableRow {
     cells: string[];
   }
   
+  /**
+   * Split one row into trimmed cells. The outer pipes are optional, because they
+   * are optional in GitHub-flavored markdown: `Refdes | Pin | Net` renders as a
+   * table exactly like `| Refdes | Pin | Net |` does, and a hand- or LLM-authored
+   * doc may legitimately be written either way.
+   */
+  function splitRow(line: string): string[] {
+    return line
+      .replace(/^\|/, '')
+      .replace(/\|$/, '')
+      .split('|')
+      .map((c) => c.trim());
+  }
+
+  /** `|---|:--:|` and friends: the row separating a header from its data. */
+  function isSeparatorRow(cells: string[]): boolean {
+    return cells.length > 0 && cells.every((c) => /^:?-+:?$/.test(c));
+  }
+
   /**
    * Parses every markdown pipe-table row out of a document, across however
    * many tables the file contains, skipping separator rows (e.g. `|---|---|`).
@@ -67,28 +86,50 @@ export interface TableRow {
    * it loops on finish forever. Resolving by header name fixes that.
    */
   export function parseCanonicalTables(md: string): Array<{ header: TableRow; rows: TableRow[] }> {
-    const groups: TableRow[][] = [];
-    let current: TableRow[] | null = null;
+    type Line = { cells: string[]; separator: boolean };
+    const groups: Line[][] = [];
+    let current: Line[] | null = null;
+    let width = 0; // column count of the open group, set by its first line
     for (const line of md.split('\n')) {
       const t = line.trim();
-      if (!t.startsWith('|')) {
+      if (!t.includes('|')) {
         current = null; // a blank or prose line terminates the current table
         continue;
       }
-      const cells = t
-        .split('|')
-        .slice(1, -1)
-        .map((c) => c.trim());
-      if (cells.every((c) => /^:?-+:?$/.test(c))) continue; // separator row: stays within the table
+      const cells = splitRow(t);
+      // Outer pipes make a line unambiguously a table row. Without them, a
+      // pipe-bearing prose line (`Legend: A | B`) is indistinguishable from a
+      // row by shape alone, so the column count decides: matching the open
+      // table's width keeps it as a row, a mismatch ends the table there rather
+      // than reading the prose as a part/pin. The line still opens a new group,
+      // in case it is itself the header of an un-piped table.
+      if (current && !t.startsWith('|') && cells.length !== width) current = null;
       if (!current) {
         current = [];
+        width = cells.length;
         groups.push(current);
       }
-      current.push({ cells });
+      // The separator row stays in the group so the header can be located
+      // relative to it; it is dropped from the rows returned below.
+      current.push({ cells, separator: isSeparatorRow(cells) });
     }
     const tables: Array<{ header: TableRow; rows: TableRow[] }> = [];
     for (const g of groups) {
-      if (g.length && isHeader(g[0]!)) tables.push({ header: g[0]!, rows: g.slice(1) });
+      // The header is the row directly above the separator. Falling back to the
+      // first row keeps a table that omits the separator working, and anchoring
+      // on the separator means a stray pipe-bearing prose line immediately above
+      // a table no longer hides it.
+      const sep = g.findIndex((l) => l.separator);
+      const headerIdx = sep > 0 ? sep - 1 : 0;
+      const header = g[headerIdx];
+      if (!header || header.separator || !isHeader({ cells: header.cells })) continue;
+      tables.push({
+        header: { cells: header.cells },
+        rows: g
+          .slice(headerIdx + 1)
+          .filter((l) => !l.separator)
+          .map((l) => ({ cells: l.cells })),
+      });
     }
     return tables;
   }

package/src/openspec/cli.ts

@@ -1,6 +1,7 @@
 import { execa } from 'execa';
 import { existsSync } from 'node:fs';
 import path from 'node:path';
+import { isNotFoundError } from '../util/preflight.js';
 
 /**
  * OpenSpec is driven as a subprocess, same pattern as kicad-cli (SPEC §2.6).
@@ -17,8 +18,8 @@ async function openspec(repo: string, args: string[]): Promise<OpenSpecResult> {
     const { stdout, stderr } = await execa('openspec', args, { cwd: repo });
     return { ok: true, output: [stdout, stderr].filter(Boolean).join('\n') };
   } catch (err) {
-    const e = err as { stdout?: string; stderr?: string; code?: string; message: string };
-    if (e.code === 'ENOENT') {
+    const e = err as { stdout?: string; stderr?: string; code?: string; message: string; exitCode?: number };
+    if (isNotFoundError(e)) {
       return { ok: false, output: 'openspec CLI not found on PATH (npm i -g @fission-ai/openspec)' };
     }
     return { ok: false, output: [e.stdout, e.stderr].filter(Boolean).join('\n') || e.message };

package/src/util/preflight.ts

@@ -23,6 +23,24 @@ export function formatPreflightFailure(reason: string, why: string, remedy: stri
   return [reason, '', `why it failed: ${why}`, 'to fix:', ...steps].join('\n');
 }
 
+export function isNotFoundError(err: any): boolean {
+  if (!err) return false;
+  if (err.code === 'ENOENT') return true;
+  if (process.platform === 'win32') {
+    const msg = String(err.stderr || err.message || '');
+    if (err.exitCode === 9009) {
+      return (
+        msg.includes('is not recognized') ||
+        msg.includes('cannot find the path specified')
+      );
+    }
+    if (err.exitCode === 1) {
+      return msg.includes('is not recognized');
+    }
+  }
+  return false;
+}
+
 /** Default minimum free space to start a run: 2 GiB. A create run emits gerbers,
  *  STEP, SVG renders and KiCad local history; 2 GiB is comfortably above a
  *  single board's output while still catching a nearly-full disk. */

package/src/util/redact.ts

@@ -5,10 +5,14 @@
  */
 const PATTERNS: RegExp[] = [
   /sk-[A-Za-z0-9_-]+/g,
-  /Bearer\s+[A-Za-z0-9._-]{16,}/g,
+  // Auth schemes are case-insensitive (RFC 7235 §2.1), and the token charset has
+  // to include base64's +, / and = or the match stops at the first one and the
+  // tail of the secret gets written out verbatim.
+  /Bearer\s+[A-Za-z0-9._+/=-]{16,}/gi,
   // Registry and forge tokens: a transcript that quotes a publish command or a
   // failing CI log can carry these just as easily as a model API key.
-  /npm_[A-Za-z0-9]{36,}/g,
+  // npm also issues UUID-shaped tokens, so the charset allows dashes.
+  /npm_[A-Za-z0-9-]{36,}/g,
   /gh[pousr]_[A-Za-z0-9]{36,}/g,
   /github_pat_[A-Za-z0-9_]{22,}/g,
 ];