cowork-cli 2.0.0 → 2.1.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cowork-cli",
-  "version": "2.0.0",
+  "version": "2.1.0",
   "description": "work with cowork",
   "bin": {
     "cwk": "bin/cli.js"

package/src/main.js

@@ -15,8 +15,20 @@ const PKG_PATH = path.join(__dirname, '../package.json');
  * @param {string[]} args Command line arguments.
  */
 export default async function main(args) {
+  let pipedData = '';
+  if (!process.stdin.isTTY) {
+    try {
+      for await (const chunk of process.stdin) {
+        pipedData += chunk;
+      }
+      pipedData = pipedData.trim();
+    } catch (err) {
+      logger.error(`Error reading from stdin: ${err.message}`);
+    }
+  }
+
   // Handle empty arguments or help flags
-  if (args.length === 0 || args[0] === '-h' || args[0] === '--help') {
+  if ((args.length === 0 && !pipedData) || args[0] === '-h' || args[0] === '--help') {
     show_help();
     return;
   }
@@ -33,7 +45,12 @@ export default async function main(args) {
   }
 
   // Handle query execution
-  const query = args[0];
+  let query = args.join(' ').trim();
+  if (pipedData) {
+    query = query
+      ? `${query}\n\n[Piped Input]:\n${pipedData}`
+      : `Analyze the following data:\n\n[Piped Input]:\n${pipedData}`;
+  }
   const config = loadConfig();
 
   // clientLoader handles config validation and throws if invalid

package/src/utils/fsUtils.js

@@ -207,31 +207,51 @@ export function clearIgnoreCache() {
  * and the **last matching pattern wins**.  Negation patterns (`!`) can
  * therefore un-ignore a previously ignored name.
  *
- * @param {string}   name       Item basename.
- * @param {Object[]} ignoreList Structured pattern objects.
+ * @param {string}   name         Item basename.
+ * @param {Object[]} ignoreList   Structured pattern objects.
  * @param {Object}   [options]
- * @param {boolean}  [options.isDirectory] Whether the item is a directory.
+ * @param {boolean}  [options.isDirectory]   Whether the item is a directory.
  *                   When omitted, directory-only patterns match regardless
  *                   (backward-compatible with existing callers).
+ * @param {string}   [options.relativePath]  Path relative to the project root
+ *                   (e.g. `"src/internal/foo.js"`).  When provided, patterns
+ *                   that contain a `/` are tested against this value instead
+ *                   of being skipped.  When omitted the old skip behaviour is
+ *                   preserved for backward compatibility.
  * @returns {boolean} `true` if the item should be skipped.
  */
 export function shouldIgnore(name, ignoreList, options = {}) {
-  const { isDirectory } = options;
+  const { isDirectory, relativePath } = options;
   let ignored = false;
 
   for (const entry of ignoreList) {
-    // Path-containing patterns (e.g. `docs/internal`) require full
-    // relative-path matching which callers don't supply — skip them.
-    if (entry.hasSlash) continue;
-
     // Directory-only patterns (`build/`) don't apply to files.
     // When `isDirectory` is undefined the caller didn't say, so we match
     // to preserve backward compat with callers that only pass basenames.
     if (entry.dirOnly && isDirectory === false) continue;
 
-    const matches = entry.hasGlob && entry.regex
-      ? entry.regex.test(name)
-      : name === entry.pattern;
+    let matches = false;
+
+    if (entry.hasSlash) {
+      // Path-scoped pattern — needs a full relative path to evaluate.
+      // Without one we conservatively skip it (backward-compatible).
+      if (!relativePath) continue;
+
+      if (entry.hasGlob && entry.regex) {
+        matches = entry.regex.test(relativePath);
+      } else {
+        // Exact segment match: the pattern must equal the relative path
+        // OR appear as a leading path prefix followed by a separator.
+        matches =
+          relativePath === entry.pattern ||
+          relativePath.startsWith(entry.pattern + '/');
+      }
+    } else {
+      // Basename-only pattern — match against the entry name.
+      matches = entry.hasGlob && entry.regex
+        ? entry.regex.test(name)
+        : name === entry.pattern;
+    }
 
     if (matches) {
       ignored = !entry.negated;
@@ -263,7 +283,7 @@ export function safePath(inputPath) {
  *
  * Rejects:
  *  1. Symbolic links (could escape the project sandbox).
- *  2. Names matched by the ignore list.
+ *  2. Names matched by the ignore list (basename AND path-scoped patterns).
  *  3. Paths that resolve outside `process.cwd()`.
  *
  * @param {import('fs').Dirent} dirent      Directory entry from `readdir`.
@@ -274,12 +294,15 @@ export function safePath(inputPath) {
 export function isSafeEntry(dirent, parentPath, ignoreList) {
   if (dirent.isSymbolicLink()) return false;
 
-  const isDir = dirent.isDirectory();
-  if (shouldIgnore(dirent.name, ignoreList, { isDirectory: isDir })) return false;
-
-  const resolved = path.resolve(parentPath, dirent.name);
   const root = process.cwd();
+  const resolved = path.resolve(parentPath, dirent.name);
   if (resolved !== root && !resolved.startsWith(root + path.sep)) return false;
 
+  const isDir = dirent.isDirectory();
+  // Compute the relative path so shouldIgnore() can evaluate path-scoped
+  // patterns like `tests/fixtures/` in addition to bare-name patterns.
+  const relativePath = path.relative(root, resolved);
+  if (shouldIgnore(dirent.name, ignoreList, { isDirectory: isDir, relativePath })) return false;
+
   return true;
 }