@tricknowtech/context 0.1.0

package/dist/index.d.cts

@@ -0,0 +1,269 @@
+/** Root of the user's global Claude directory (~/.claude), overridable for tests. */
+declare function userClaudeDir(): string;
+/**
+ * Claude Code keys its per-project directories by the working directory with
+ * every non-alphanumeric character folded to a dash — `/root/my-project`
+ * becomes `-root-my-project`. Restoring on a machine where the repo lives at
+ * a different path means recomputing this key, which is why nothing may hard-
+ * code it.
+ */
+declare function cwdKey(absPath: string): string;
+/**
+ * Placeholders that make a restore path portable across machines.
+ *
+ * `cwdKey` is the important one: Claude Code's per-project directories are
+ * named after the absolute project path, so a path captured on one machine
+ * embeds that machine's layout. Templating the key out and recomputing it at
+ * restore time is what lets the same context land correctly in a repo cloned
+ * to a different directory.
+ */
+interface TemplateContext {
+    userClaude: string;
+    project: string;
+    cwdKey: string;
+}
+declare function makeTemplate(absPath: string, ctx: TemplateContext): string;
+declare function resolveTemplate(template: string, ctx: TemplateContext): string;
+/**
+ * Absolute paths git already tracks in this repo. Anything in here is skipped
+ * by the collector: it travels with the code already, and copying it into the
+ * store would duplicate it and create two sources of truth that drift.
+ *
+ * Returns an empty set when not in a git repo (or git is unavailable), which
+ * correctly degrades to "copy everything".
+ */
+declare function gitTrackedSet(root: string): Set<string>;
+declare function isGitRepo(root: string): boolean;
+declare function matchesAny(relPath: string, patterns: string[]): boolean;
+interface WalkOptions {
+    /** Patterns (relative to `root`) to skip entirely. */
+    exclude?: string[];
+    /** Hard cap so a mis-pointed root can't hang the CLI. */
+    maxFiles?: number;
+}
+/** Recursively list files under `root`, returning absolute paths. */
+declare function walk(root: string, opts?: WalkOptions): string[];
+declare function formatBytes(n: number): string;
+
+/**
+ * Shared types for the context-sync engine.
+ *
+ * The collector and the stores are deliberately decoupled: the collector
+ * decides *what* is context (tier rules, git-tracked detection, secret
+ * scanning), a Store decides *how* it is persisted. LocalStore writes plain
+ * mirrored files into the repo; a future CloudStore writes content-addressed
+ * blobs. Both consume the same CollectedFile[].
+ */
+/** Which slice of context a file belongs to. */
+type Tier = 'core' | 'handoff' | 'artifacts' | 'transcripts';
+declare const ALL_TIERS: Tier[];
+/**
+ * Tiers a local (in-repo) store will accept. Transcripts are excluded on
+ * purpose — they run to hundreds of MB and are append-only, so committing
+ * them would permanently bloat every clone of the repo, and they carry the
+ * largest secret-leak surface (full tool output, including anything read
+ * out of a .env).
+ */
+declare const LOCAL_TIERS: Tier[];
+/** Where a file was collected from — decides how it is restored. */
+type SourceRoot = 
+/** Inside the project/repo itself. */
+'project'
+/** Under the user's global Claude directory (~/.claude). */
+ | 'user';
+interface CollectedFile {
+    /**
+     * Path *within the store*, always POSIX-style and relative.
+     * e.g. `memory/nginx_upstream_ip_cache.md`, `skills/graphify/SKILL.md`.
+     */
+    storePath: string;
+    /** Absolute path this was read from on this machine. */
+    sourcePath: string;
+    sourceRoot: SourceRoot;
+    tier: Tier;
+    size: number;
+    /**
+     * Absolute path to restore to, expressed as a template with `{userClaude}`
+     * and `{project}` placeholders so it can be re-resolved on a machine where
+     * the repo (or home dir) lives somewhere else. This is what makes restore
+     * portable — see resolveTemplate() in fsutil.ts.
+     */
+    restoreTemplate: string;
+}
+interface ProjectConfig {
+    /** Stable id for this project, used to correlate with a cloud remote. */
+    projectId: string;
+    name: string;
+    /**
+     * Absolute project root recorded at init time on the machine that ran it.
+     * Restoring elsewhere diffs this against the current root to rewrite the
+     * cwd-derived directory keys Claude Code uses (e.g. `-root-my-project`).
+     */
+    rootHint: string;
+    tiers: Tier[];
+    /** Extra project-relative dirs to capture as `artifacts`. */
+    artifactPaths: string[];
+    /** Glob-ish patterns excluded from collection, on top of the hard-coded denylist. */
+    exclude: string[];
+    remotes: Record<string, RemoteConfig>;
+}
+interface RemoteConfig {
+    type: 'tricknowtech';
+    url: string;
+    e2ee: boolean;
+}
+interface Handoff {
+    /** ISO timestamp written by the slash command. */
+    updatedAt: string;
+    /** What the session was trying to achieve. */
+    goal: string;
+    /** Decisions already made, so they aren't re-litigated on the next device. */
+    decisions: string[];
+    /** Work explicitly left unfinished. */
+    openThreads: string[];
+    /** Files touched, for fast re-orientation. */
+    filesTouched: string[];
+    /** The single next action to take. */
+    nextStep: string;
+    /** Free-form notes the model wants to carry over. */
+    notes?: string;
+}
+interface SecretHit {
+    storePath: string;
+    line: number;
+    rule: string;
+    /** The matched text, already masked — never the raw secret. */
+    preview: string;
+}
+
+interface CollectResult {
+    files: CollectedFile[];
+    /** Project files skipped because git already carries them. */
+    skippedTracked: string[];
+    ctx: TemplateContext;
+}
+/**
+ * Decide what constitutes this project's LLM context.
+ *
+ * Two roots are scanned, and they are treated very differently:
+ *
+ *  - **The project itself** — anything git already tracks is *skipped*. It
+ *    travels with the code, so copying it into the store would duplicate it
+ *    and create a second copy that silently drifts out of date.
+ *  - **The user's global Claude directory** — this is the real payload. The
+ *    per-project memory, skills, and global instructions live outside the
+ *    repo and are exactly what never makes it to a second machine today.
+ */
+declare function collect(projectRoot: string, cfg: ProjectConfig, tiers: Tier[]): CollectResult;
+declare function summarize(files: CollectedFile[]): Record<Tier, {
+    count: number;
+    bytes: number;
+}>;
+
+declare const STORE_DIR = ".contextsync";
+declare const CONFIG_FILE = "config.json";
+declare const HANDOFF_FILE = "handoff.json";
+/**
+ * Paths never collected, regardless of tier or user config.
+ *
+ * These are credentials, not context. `.credentials.json` holds the live
+ * Claude OAuth token and `.claude.json` holds account state; a `.env` is the
+ * canonical place a project keeps its secrets. None of them belong in a store
+ * that gets committed to a repo.
+ */
+declare const HARD_DENY: string[];
+declare const DEFAULT_EXCLUDE: string[];
+declare function defaultConfig(projectRoot: string): ProjectConfig;
+/**
+ * Walk up from `start` looking for an existing store, then for a repo root.
+ * Mirrors how git resolves its own root so the CLI works from subdirectories.
+ */
+declare function findProjectRoot(start?: string): string | null;
+declare function storeDir(projectRoot: string): string;
+declare function configPath(projectRoot: string): string;
+declare function loadConfig(projectRoot: string): ProjectConfig | null;
+declare function saveConfig(projectRoot: string, cfg: ProjectConfig): void;
+
+declare const SLASH_COMMAND_PATH = ".claude/commands/context.md";
+/**
+ * The `/context` slash command.
+ *
+ * This exists because of a hard division of labour: the CLI can read the
+ * filesystem but has no idea what the conversation was about, and the model
+ * knows exactly what the conversation was about but cannot walk the disk. A
+ * slash command is a prompt, so it is the one place both are available —
+ * the model writes the handoff, then shells out to the CLI to persist it.
+ */
+declare const SLASH_COMMAND_BODY = "---\ndescription: Sync this project's LLM context (memory, skills, instructions, handoff)\nargument-hint: \"push | pull | status\"\nallowed-tools: Bash(npx @tricknowtech/context:*), Read, Write\n---\n\nRun the context-sync action requested in: $ARGUMENTS\n(If no argument was given, treat it as `status`.)\n\n## push\n\n1. Write a handoff summary of THIS conversation to `.contextsync/handoff.json`.\n   Use exactly this shape \u2014 it is read back verbatim on the other device:\n\n   ```json\n   {\n     \"updatedAt\": \"<ISO 8601 timestamp>\",\n     \"goal\": \"<what this session set out to achieve, one or two sentences>\",\n     \"decisions\": [\"<decisions already made, so they aren't re-litigated>\"],\n     \"openThreads\": [\"<work explicitly left unfinished>\"],\n     \"filesTouched\": [\"<repo-relative paths changed this session>\"],\n     \"nextStep\": \"<the single next action someone should take>\",\n     \"notes\": \"<anything else worth carrying over; optional>\"\n   }\n   ```\n\n   Be specific and factual. Write what was actually decided and actually left\n   open \u2014 a vague handoff is worse than none, because it reads as progress.\n   Never put credentials, tokens, or .env values in any field.\n\n2. Then run: `npx @tricknowtech/context push`\n\n3. Report what was synced. If the push was refused for possible secrets, show\n   the findings and STOP \u2014 do not re-run with `--allow-secrets` unless the\n   user explicitly tells you the hits are false positives.\n\n## pull\n\n1. Run: `npx @tricknowtech/context pull`\n2. Read `.contextsync/handoff.json` and summarize for the user, out loud:\n   the goal, what was decided, what is still open, and the next step.\n3. If any files were skipped as conflicting, list them and ask before forcing.\n\n## status\n\nRun: `npx @tricknowtech/context status` and summarize the result.\n";
+declare function installSlashCommand(projectRoot: string): {
+    path: string;
+    written: boolean;
+};
+/**
+ * Keep heavyweight, opt-in tiers out of git unless the user asked for them.
+ * Artifacts are regenerable derived indexes; committing them by accident is a
+ * common way to add tens of MB to a repo that nobody notices until clone time.
+ */
+declare function ensureGitignoreEntries(projectRoot: string, artifactsEnabled: boolean): string[];
+
+declare function scanFiles(files: CollectedFile[]): SecretHit[];
+declare function formatHits(hits: SecretHit[]): string;
+
+declare const MANIFEST_FILE = "manifest.json";
+interface ManifestEntry {
+    storePath: string;
+    restoreTemplate: string;
+    tier: Tier;
+    sourceRoot: 'project' | 'user';
+    size: number;
+}
+interface Manifest {
+    version: 1;
+    updatedAt: string;
+    /** Project root on the machine that wrote this, for diagnostics on restore. */
+    writtenFrom: string;
+    entries: ManifestEntry[];
+}
+interface RestoreResult {
+    restored: string[];
+    skipped: string[];
+}
+/**
+ * Persistence backend for collected context.
+ *
+ * LocalStore is the only implementation today. A CloudStore will implement the
+ * same surface over content-addressed blobs, which is why write/read/restore
+ * are expressed in terms of CollectedFile/Manifest rather than file paths.
+ */
+interface Store {
+    write(files: CollectedFile[], projectRoot: string): Manifest;
+    readManifest(): Manifest | null;
+    restore(ctx: TemplateContext, opts?: {
+        force?: boolean;
+    }): RestoreResult;
+    readHandoff(): Handoff | null;
+    writeHandoff(handoff: Handoff): void;
+}
+/**
+ * Stores context as plain mirrored files inside the repo.
+ *
+ * Deliberately *not* content-addressed. Git already does content-addressing
+ * and dedup internally, so a blob store nested inside a repo would be
+ * redundant, unreviewable in a pull request, and unmergeable on conflict.
+ * Plain files diff cleanly and merge with git's normal machinery — which is
+ * the entire reason local mode needs no conflict-resolution layer of its own.
+ */
+declare class LocalStore implements Store {
+    private readonly projectRoot;
+    constructor(projectRoot: string);
+    private get dir();
+    write(files: CollectedFile[], projectRoot: string): Manifest;
+    readManifest(): Manifest | null;
+    restore(ctx: TemplateContext, opts?: {
+        force?: boolean;
+    }): RestoreResult;
+    readHandoff(): Handoff | null;
+    writeHandoff(handoff: Handoff): void;
+}
+
+export { ALL_TIERS, CONFIG_FILE, type CollectResult, type CollectedFile, DEFAULT_EXCLUDE, HANDOFF_FILE, HARD_DENY, type Handoff, LOCAL_TIERS, LocalStore, MANIFEST_FILE, type Manifest, type ManifestEntry, type ProjectConfig, type RemoteConfig, type RestoreResult, SLASH_COMMAND_BODY, SLASH_COMMAND_PATH, STORE_DIR, type SecretHit, type SourceRoot, type Store, type TemplateContext, type Tier, collect, configPath, cwdKey, defaultConfig, ensureGitignoreEntries, findProjectRoot, formatBytes, formatHits, gitTrackedSet, installSlashCommand, isGitRepo, loadConfig, makeTemplate, matchesAny, resolveTemplate, saveConfig, scanFiles, storeDir, summarize, userClaudeDir, walk };

package/dist/index.d.ts

@@ -0,0 +1,269 @@
+/** Root of the user's global Claude directory (~/.claude), overridable for tests. */
+declare function userClaudeDir(): string;
+/**
+ * Claude Code keys its per-project directories by the working directory with
+ * every non-alphanumeric character folded to a dash — `/root/my-project`
+ * becomes `-root-my-project`. Restoring on a machine where the repo lives at
+ * a different path means recomputing this key, which is why nothing may hard-
+ * code it.
+ */
+declare function cwdKey(absPath: string): string;
+/**
+ * Placeholders that make a restore path portable across machines.
+ *
+ * `cwdKey` is the important one: Claude Code's per-project directories are
+ * named after the absolute project path, so a path captured on one machine
+ * embeds that machine's layout. Templating the key out and recomputing it at
+ * restore time is what lets the same context land correctly in a repo cloned
+ * to a different directory.
+ */
+interface TemplateContext {
+    userClaude: string;
+    project: string;
+    cwdKey: string;
+}
+declare function makeTemplate(absPath: string, ctx: TemplateContext): string;
+declare function resolveTemplate(template: string, ctx: TemplateContext): string;
+/**
+ * Absolute paths git already tracks in this repo. Anything in here is skipped
+ * by the collector: it travels with the code already, and copying it into the
+ * store would duplicate it and create two sources of truth that drift.
+ *
+ * Returns an empty set when not in a git repo (or git is unavailable), which
+ * correctly degrades to "copy everything".
+ */
+declare function gitTrackedSet(root: string): Set<string>;
+declare function isGitRepo(root: string): boolean;
+declare function matchesAny(relPath: string, patterns: string[]): boolean;
+interface WalkOptions {
+    /** Patterns (relative to `root`) to skip entirely. */
+    exclude?: string[];
+    /** Hard cap so a mis-pointed root can't hang the CLI. */
+    maxFiles?: number;
+}
+/** Recursively list files under `root`, returning absolute paths. */
+declare function walk(root: string, opts?: WalkOptions): string[];
+declare function formatBytes(n: number): string;
+
+/**
+ * Shared types for the context-sync engine.
+ *
+ * The collector and the stores are deliberately decoupled: the collector
+ * decides *what* is context (tier rules, git-tracked detection, secret
+ * scanning), a Store decides *how* it is persisted. LocalStore writes plain
+ * mirrored files into the repo; a future CloudStore writes content-addressed
+ * blobs. Both consume the same CollectedFile[].
+ */
+/** Which slice of context a file belongs to. */
+type Tier = 'core' | 'handoff' | 'artifacts' | 'transcripts';
+declare const ALL_TIERS: Tier[];
+/**
+ * Tiers a local (in-repo) store will accept. Transcripts are excluded on
+ * purpose — they run to hundreds of MB and are append-only, so committing
+ * them would permanently bloat every clone of the repo, and they carry the
+ * largest secret-leak surface (full tool output, including anything read
+ * out of a .env).
+ */
+declare const LOCAL_TIERS: Tier[];
+/** Where a file was collected from — decides how it is restored. */
+type SourceRoot = 
+/** Inside the project/repo itself. */
+'project'
+/** Under the user's global Claude directory (~/.claude). */
+ | 'user';
+interface CollectedFile {
+    /**
+     * Path *within the store*, always POSIX-style and relative.
+     * e.g. `memory/nginx_upstream_ip_cache.md`, `skills/graphify/SKILL.md`.
+     */
+    storePath: string;
+    /** Absolute path this was read from on this machine. */
+    sourcePath: string;
+    sourceRoot: SourceRoot;
+    tier: Tier;
+    size: number;
+    /**
+     * Absolute path to restore to, expressed as a template with `{userClaude}`
+     * and `{project}` placeholders so it can be re-resolved on a machine where
+     * the repo (or home dir) lives somewhere else. This is what makes restore
+     * portable — see resolveTemplate() in fsutil.ts.
+     */
+    restoreTemplate: string;
+}
+interface ProjectConfig {
+    /** Stable id for this project, used to correlate with a cloud remote. */
+    projectId: string;
+    name: string;
+    /**
+     * Absolute project root recorded at init time on the machine that ran it.
+     * Restoring elsewhere diffs this against the current root to rewrite the
+     * cwd-derived directory keys Claude Code uses (e.g. `-root-my-project`).
+     */
+    rootHint: string;
+    tiers: Tier[];
+    /** Extra project-relative dirs to capture as `artifacts`. */
+    artifactPaths: string[];
+    /** Glob-ish patterns excluded from collection, on top of the hard-coded denylist. */
+    exclude: string[];
+    remotes: Record<string, RemoteConfig>;
+}
+interface RemoteConfig {
+    type: 'tricknowtech';
+    url: string;
+    e2ee: boolean;
+}
+interface Handoff {
+    /** ISO timestamp written by the slash command. */
+    updatedAt: string;
+    /** What the session was trying to achieve. */
+    goal: string;
+    /** Decisions already made, so they aren't re-litigated on the next device. */
+    decisions: string[];
+    /** Work explicitly left unfinished. */
+    openThreads: string[];
+    /** Files touched, for fast re-orientation. */
+    filesTouched: string[];
+    /** The single next action to take. */
+    nextStep: string;
+    /** Free-form notes the model wants to carry over. */
+    notes?: string;
+}
+interface SecretHit {
+    storePath: string;
+    line: number;
+    rule: string;
+    /** The matched text, already masked — never the raw secret. */
+    preview: string;
+}
+
+interface CollectResult {
+    files: CollectedFile[];
+    /** Project files skipped because git already carries them. */
+    skippedTracked: string[];
+    ctx: TemplateContext;
+}
+/**
+ * Decide what constitutes this project's LLM context.
+ *
+ * Two roots are scanned, and they are treated very differently:
+ *
+ *  - **The project itself** — anything git already tracks is *skipped*. It
+ *    travels with the code, so copying it into the store would duplicate it
+ *    and create a second copy that silently drifts out of date.
+ *  - **The user's global Claude directory** — this is the real payload. The
+ *    per-project memory, skills, and global instructions live outside the
+ *    repo and are exactly what never makes it to a second machine today.
+ */
+declare function collect(projectRoot: string, cfg: ProjectConfig, tiers: Tier[]): CollectResult;
+declare function summarize(files: CollectedFile[]): Record<Tier, {
+    count: number;
+    bytes: number;
+}>;
+
+declare const STORE_DIR = ".contextsync";
+declare const CONFIG_FILE = "config.json";
+declare const HANDOFF_FILE = "handoff.json";
+/**
+ * Paths never collected, regardless of tier or user config.
+ *
+ * These are credentials, not context. `.credentials.json` holds the live
+ * Claude OAuth token and `.claude.json` holds account state; a `.env` is the
+ * canonical place a project keeps its secrets. None of them belong in a store
+ * that gets committed to a repo.
+ */
+declare const HARD_DENY: string[];
+declare const DEFAULT_EXCLUDE: string[];
+declare function defaultConfig(projectRoot: string): ProjectConfig;
+/**
+ * Walk up from `start` looking for an existing store, then for a repo root.
+ * Mirrors how git resolves its own root so the CLI works from subdirectories.
+ */
+declare function findProjectRoot(start?: string): string | null;
+declare function storeDir(projectRoot: string): string;
+declare function configPath(projectRoot: string): string;
+declare function loadConfig(projectRoot: string): ProjectConfig | null;
+declare function saveConfig(projectRoot: string, cfg: ProjectConfig): void;
+
+declare const SLASH_COMMAND_PATH = ".claude/commands/context.md";
+/**
+ * The `/context` slash command.
+ *
+ * This exists because of a hard division of labour: the CLI can read the
+ * filesystem but has no idea what the conversation was about, and the model
+ * knows exactly what the conversation was about but cannot walk the disk. A
+ * slash command is a prompt, so it is the one place both are available —
+ * the model writes the handoff, then shells out to the CLI to persist it.
+ */
+declare const SLASH_COMMAND_BODY = "---\ndescription: Sync this project's LLM context (memory, skills, instructions, handoff)\nargument-hint: \"push | pull | status\"\nallowed-tools: Bash(npx @tricknowtech/context:*), Read, Write\n---\n\nRun the context-sync action requested in: $ARGUMENTS\n(If no argument was given, treat it as `status`.)\n\n## push\n\n1. Write a handoff summary of THIS conversation to `.contextsync/handoff.json`.\n   Use exactly this shape \u2014 it is read back verbatim on the other device:\n\n   ```json\n   {\n     \"updatedAt\": \"<ISO 8601 timestamp>\",\n     \"goal\": \"<what this session set out to achieve, one or two sentences>\",\n     \"decisions\": [\"<decisions already made, so they aren't re-litigated>\"],\n     \"openThreads\": [\"<work explicitly left unfinished>\"],\n     \"filesTouched\": [\"<repo-relative paths changed this session>\"],\n     \"nextStep\": \"<the single next action someone should take>\",\n     \"notes\": \"<anything else worth carrying over; optional>\"\n   }\n   ```\n\n   Be specific and factual. Write what was actually decided and actually left\n   open \u2014 a vague handoff is worse than none, because it reads as progress.\n   Never put credentials, tokens, or .env values in any field.\n\n2. Then run: `npx @tricknowtech/context push`\n\n3. Report what was synced. If the push was refused for possible secrets, show\n   the findings and STOP \u2014 do not re-run with `--allow-secrets` unless the\n   user explicitly tells you the hits are false positives.\n\n## pull\n\n1. Run: `npx @tricknowtech/context pull`\n2. Read `.contextsync/handoff.json` and summarize for the user, out loud:\n   the goal, what was decided, what is still open, and the next step.\n3. If any files were skipped as conflicting, list them and ask before forcing.\n\n## status\n\nRun: `npx @tricknowtech/context status` and summarize the result.\n";
+declare function installSlashCommand(projectRoot: string): {
+    path: string;
+    written: boolean;
+};
+/**
+ * Keep heavyweight, opt-in tiers out of git unless the user asked for them.
+ * Artifacts are regenerable derived indexes; committing them by accident is a
+ * common way to add tens of MB to a repo that nobody notices until clone time.
+ */
+declare function ensureGitignoreEntries(projectRoot: string, artifactsEnabled: boolean): string[];
+
+declare function scanFiles(files: CollectedFile[]): SecretHit[];
+declare function formatHits(hits: SecretHit[]): string;
+
+declare const MANIFEST_FILE = "manifest.json";
+interface ManifestEntry {
+    storePath: string;
+    restoreTemplate: string;
+    tier: Tier;
+    sourceRoot: 'project' | 'user';
+    size: number;
+}
+interface Manifest {
+    version: 1;
+    updatedAt: string;
+    /** Project root on the machine that wrote this, for diagnostics on restore. */
+    writtenFrom: string;
+    entries: ManifestEntry[];
+}
+interface RestoreResult {
+    restored: string[];
+    skipped: string[];
+}
+/**
+ * Persistence backend for collected context.
+ *
+ * LocalStore is the only implementation today. A CloudStore will implement the
+ * same surface over content-addressed blobs, which is why write/read/restore
+ * are expressed in terms of CollectedFile/Manifest rather than file paths.
+ */
+interface Store {
+    write(files: CollectedFile[], projectRoot: string): Manifest;
+    readManifest(): Manifest | null;
+    restore(ctx: TemplateContext, opts?: {
+        force?: boolean;
+    }): RestoreResult;
+    readHandoff(): Handoff | null;
+    writeHandoff(handoff: Handoff): void;
+}
+/**
+ * Stores context as plain mirrored files inside the repo.
+ *
+ * Deliberately *not* content-addressed. Git already does content-addressing
+ * and dedup internally, so a blob store nested inside a repo would be
+ * redundant, unreviewable in a pull request, and unmergeable on conflict.
+ * Plain files diff cleanly and merge with git's normal machinery — which is
+ * the entire reason local mode needs no conflict-resolution layer of its own.
+ */
+declare class LocalStore implements Store {
+    private readonly projectRoot;
+    constructor(projectRoot: string);
+    private get dir();
+    write(files: CollectedFile[], projectRoot: string): Manifest;
+    readManifest(): Manifest | null;
+    restore(ctx: TemplateContext, opts?: {
+        force?: boolean;
+    }): RestoreResult;
+    readHandoff(): Handoff | null;
+    writeHandoff(handoff: Handoff): void;
+}
+
+export { ALL_TIERS, CONFIG_FILE, type CollectResult, type CollectedFile, DEFAULT_EXCLUDE, HANDOFF_FILE, HARD_DENY, type Handoff, LOCAL_TIERS, LocalStore, MANIFEST_FILE, type Manifest, type ManifestEntry, type ProjectConfig, type RemoteConfig, type RestoreResult, SLASH_COMMAND_BODY, SLASH_COMMAND_PATH, STORE_DIR, type SecretHit, type SourceRoot, type Store, type TemplateContext, type Tier, collect, configPath, cwdKey, defaultConfig, ensureGitignoreEntries, findProjectRoot, formatBytes, formatHits, gitTrackedSet, installSlashCommand, isGitRepo, loadConfig, makeTemplate, matchesAny, resolveTemplate, saveConfig, scanFiles, storeDir, summarize, userClaudeDir, walk };

package/dist/index.js

@@ -0,0 +1,68 @@
+import {
+  ALL_TIERS,
+  CONFIG_FILE,
+  DEFAULT_EXCLUDE,
+  HANDOFF_FILE,
+  HARD_DENY,
+  LOCAL_TIERS,
+  LocalStore,
+  MANIFEST_FILE,
+  SLASH_COMMAND_BODY,
+  SLASH_COMMAND_PATH,
+  STORE_DIR,
+  collect,
+  configPath,
+  cwdKey,
+  defaultConfig,
+  ensureGitignoreEntries,
+  findProjectRoot,
+  formatBytes,
+  formatHits,
+  gitTrackedSet,
+  installSlashCommand,
+  isGitRepo,
+  loadConfig,
+  makeTemplate,
+  matchesAny,
+  resolveTemplate,
+  saveConfig,
+  scanFiles,
+  storeDir,
+  summarize,
+  userClaudeDir,
+  walk
+} from "./chunk-DEH5MUFT.js";
+export {
+  ALL_TIERS,
+  CONFIG_FILE,
+  DEFAULT_EXCLUDE,
+  HANDOFF_FILE,
+  HARD_DENY,
+  LOCAL_TIERS,
+  LocalStore,
+  MANIFEST_FILE,
+  SLASH_COMMAND_BODY,
+  SLASH_COMMAND_PATH,
+  STORE_DIR,
+  collect,
+  configPath,
+  cwdKey,
+  defaultConfig,
+  ensureGitignoreEntries,
+  findProjectRoot,
+  formatBytes,
+  formatHits,
+  gitTrackedSet,
+  installSlashCommand,
+  isGitRepo,
+  loadConfig,
+  makeTemplate,
+  matchesAny,
+  resolveTemplate,
+  saveConfig,
+  scanFiles,
+  storeDir,
+  summarize,
+  userClaudeDir,
+  walk
+};

package/package.json

@@ -0,0 +1,54 @@
+{
+  "name": "@tricknowtech/context",
+  "version": "0.1.0",
+  "description": "Carry a project's LLM context — memory, skills, instructions and session handoff — between machines. Local-first, commit it to your repo.",
+  "type": "module",
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs"
+    }
+  },
+  "bin": {
+    "ctx": "./dist/cli.js",
+    "tricknowtech-context": "./dist/cli.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "sideEffects": false,
+  "scripts": {
+    "build": "tsup src/index.ts src/cli.ts --format esm,cjs --dts --clean",
+    "test": "node --import tsx --test src/*.test.ts",
+    "typecheck": "tsc --noEmit",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [
+    "tricknowtech",
+    "llm",
+    "context",
+    "claude",
+    "ai",
+    "sync",
+    "memory"
+  ],
+  "author": "Tricknowtech",
+  "license": "ISC",
+  "homepage": "https://tricknow.tech",
+  "engines": {
+    "node": ">=18"
+  },
+  "devDependencies": {
+    "@types/node": "^22.10.0",
+    "tsup": "^8.3.0",
+    "tsx": "^4.19.0",
+    "typescript": "^5.7.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}