Skip to content

wellwelwel/lagune / .claude/skills/ingest

ingest

Verified

Use before reading any .txt file, whatever its name, and whenever a task builds on GitIngest digests. Checks whether a file is a digest (a whole repository in one file) and surveys, searches, and reads it without loading it whole. Returns only the requested lines, with token estimates and anchors for a reusable synthesis.

tools/selection.ts

View on GitHub
import type { Digest, Entry, Options, Scope, Target } from './types.ts';
import { basename, posix } from 'node:path';
import { parseAnchor, parseRange } from './anchor.ts';
import { fail } from './fail.ts';
import { extensionOf, stripRoot } from './paths.ts';

const normalizeDirectory = (directory: string): string => {
  const normalized = posix.normalize(directory).replace(/^\/+|\/+$/g, '');

  return normalized === '.' ? '' : normalized;
};

const isUnder = (path: string, directory: string): boolean =>
  directory === '' || path === directory || path.startsWith(`${directory}/`);

const inScope = (entry: Entry, scope: Scope): boolean => {
  if (entry.noise && !scope.noise) return false;
  if (
    scope.under.length > 0 &&
    !scope.under.some((directory) => isUnder(entry.path, directory))
  )
    return false;
  if (
    scope.extensions.length > 0 &&
    !scope.extensions.includes(extensionOf(entry.path))
  )
    return false;
  if (
    scope.name !== null &&
    !basename(entry.path).toLowerCase().includes(scope.name.toLowerCase())
  )
    return false;

  return true;
};

export const scopeFor = (digest: Digest, scope: Scope): Scope => ({
  ...scope,
  under: scope.under.map((directory) =>
    normalizeDirectory(stripRoot(digest, directory))
  ),
});

export const selectedEntries = (digest: Digest, options: Options): Entry[] => {
  const scope = scopeFor(digest, options.scope);

  return digest.entries.filter(
    (entry) => entry.kind === 'text' && inScope(entry, scope)
  );
};

export const resolveTargets = (
  digests: Digest[],
  options: Options
): Target[] => {
  const fromAt = options.at.map(
    (text) => parseAnchor(text) ?? fail(`invalid --at: ${text}`)
  );
  const fromPaths = options.paths.map((path) => ({
    path,
    range:
      options.lines === null
        ? null
        : (parseRange(options.lines) ??
          fail(`invalid --lines: ${options.lines}`)),
  }));

  return [...fromAt, ...fromPaths].flatMap(({ path, range }) => {
    const found = digests.flatMap((digest) => {
      const entry = digest.byPath.get(stripRoot(digest, path));

      return entry === undefined ? [] : [{ digest, entry, range }];
    });

    return found.length > 0 ? found : fail(`not in any digest: ${path}`);
  });
};
receiving-code-reviewobra/superpowersUse when receiving code review feedback, before implementing suggestions, especially if feedback seems unclear or technically questionable - requires technical rigor and verification, not performative agreement or blind implementationStars: 322kUpdated Claude CodeCodexVerifiedInstall
requesting-code-reviewobra/superpowersUse when completing tasks, implementing major features, or before merging to verify work meets requirementsStars: 322kUpdated Claude CodeCodexVerifiedInstall
using-git-worktreesobra/superpowersUse when starting feature work that needs isolation from current workspace or before executing implementation plans - ensures an isolated workspace exists via native tools or git worktree fallbackStars: 322kUpdated Claude CodeCodexVerifiedInstall
verification-before-completionobra/superpowersUse when about to claim work is complete, fixed, or passing, before committing or creating PRs - requires running verification commands and confirming output before making any success claims; evidence before assertions alwaysStars: 322kUpdated Claude CodeCodexVerifiedInstall