npm - ithos - Versions diffs - 0.1.0 - Mend

ithos 0.1.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (19) hide show

package/dist/bin/ithos.d.ts ADDED Viewed

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=ithos.d.ts.map

package/dist/bin/ithos.d.ts.map ADDED Viewed

	@@ -0,0 +1 @@
1	+ {"version":3,"file":"ithos.d.ts","sourceRoot":"","sources":["../../src/bin/ithos.ts"],"names":[],"mappings":""}

package/dist/bin/ithos.js ADDED Viewed

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+import { createCli } from "../cli.js";
+await createCli().parseAsync(process.argv);

package/dist/cli.d.ts ADDED Viewed

@@ -0,0 +1,3 @@
+import { Command } from "commander";
+export declare function createCli(): Command;
+//# sourceMappingURL=cli.d.ts.map

package/dist/cli.d.ts.map ADDED Viewed

	@@ -0,0 +1 @@
1	+ {"version":3,"file":"cli.d.ts","sourceRoot":"","sources":["../src/cli.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAYpC,wBAAgB,SAAS,IAAI,OAAO,CAoGnC"}

package/dist/cli.js ADDED Viewed

@@ -0,0 +1,100 @@
+import { Command } from "commander";
+import { doctorRepository, exportMemory, initRepository, isArtifactType, recordArtifact, searchMemory, validateRepository } from "ithos-core";
+export function createCli() {
+    const program = new Command();
+    program
+        .name("ithos")
+        .description("Local-first engineering memory")
+        .version("0.1.0");
+    program
+        .command("init")
+        .description("Initialize Ithos memory in the current repository")
+        .action(async () => {
+        const result = await initRepository();
+        printList("Created", result.created);
+        printList("Already existed", result.existing);
+    });
+    program
+        .command("validate")
+        .description("Validate the Ithos repository structure")
+        .action(async () => {
+        const result = await validateRepository();
+        if (result.valid) {
+            console.log("Ithos repository is valid.");
+            return;
+        }
+        result.errors.forEach((error) => console.error(error));
+        process.exitCode = 1;
+    });
+    program
+        .command("doctor")
+        .description("Check local Ithos setup and print guidance")
+        .action(async () => {
+        const result = await doctorRepository();
+        result.messages.forEach((message) => console.log(message));
+        if (!result.ok) {
+            process.exitCode = 1;
+        }
+    });
+    program
+        .command("record")
+        .description("Record one engineering memory artifact")
+        .requiredOption("-t, --type <type>", "artifact type")
+        .requiredOption("--title <title>", "artifact title")
+        .option("-b, --body <body>", "artifact body")
+        .action(async (options) => {
+        if (!isArtifactType(options.type)) {
+            console.error(`Unsupported artifact type: ${options.type}`);
+            process.exitCode = 1;
+            return;
+        }
+        const body = options.body ?? (await readStdin());
+        if (body.trim().length === 0) {
+            console.error("Artifact body is required through --body or stdin.");
+            process.exitCode = 1;
+            return;
+        }
+        const file = await recordArtifact({
+            type: options.type,
+            title: options.title,
+            body
+        });
+        console.log(`Recorded ${file}`);
+    });
+    program
+        .command("search")
+        .description("Search Ithos markdown memory")
+        .argument("<query>", "keyword to search for")
+        .action(async (query) => {
+        const results = await searchMemory(query);
+        if (results.length === 0) {
+            console.log("No matches found.");
+            return;
+        }
+        results.forEach((result) => {
+            console.log(`${result.file}:${result.line}: ${result.text}`);
+        });
+    });
+    program
+        .command("export")
+        .description("Export Ithos markdown memory to stdout")
+        .action(async () => {
+        const result = await exportMemory();
+        process.stdout.write(result.markdown);
+    });
+    return program;
+}
+function printList(label, values) {
+    if (values.length === 0) {
+        return;
+    }
+    console.log(`${label}:`);
+    values.forEach((value) => console.log(`- ${value}`));
+}
+async function readStdin() {
+    const chunks = [];
+    for await (const chunk of process.stdin) {
+        chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+    }
+    return Buffer.concat(chunks).toString("utf8");
+}

package/dist/cli.test.d.ts ADDED Viewed

	@@ -0,0 +1,2 @@
1	+ export {};
2	+ //# sourceMappingURL=cli.test.d.ts.map

package/dist/cli.test.d.ts.map ADDED Viewed

	@@ -0,0 +1 @@
1	+ {"version":3,"file":"cli.test.d.ts","sourceRoot":"","sources":["../src/cli.test.ts"],"names":[],"mappings":""}

package/dist/cli.test.js ADDED Viewed

@@ -0,0 +1,14 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { createCli } from "./cli.js";
+test("createCli returns a configured commander program", () => {
+    const program = createCli();
+    assert.equal(program.name(), "ithos");
+    const commands = program.commands.map((cmd) => cmd.name());
+    assert.ok(commands.includes("init"));
+    assert.ok(commands.includes("validate"));
+    assert.ok(commands.includes("doctor"));
+    assert.ok(commands.includes("record"));
+    assert.ok(commands.includes("search"));
+    assert.ok(commands.includes("export"));
+});

package/dist/index.d.ts ADDED Viewed

	@@ -0,0 +1,2 @@
1	+ export { createCli } from "./cli.js";
2	+ //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map ADDED Viewed

	@@ -0,0 +1 @@
1	+ {"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,UAAU,CAAC"}

package/dist/index.js ADDED Viewed

	@@ -0,0 +1 @@
1	+ export { createCli } from "./cli.js";

package/dist/ithos.d.ts ADDED Viewed

@@ -0,0 +1,37 @@
+export type ArtifactType = "architecture" | "decisions" | "defects" | "features" | "gaps" | "lessons" | "patterns" | "regressions" | "releases" | "sessions";
+export type InitResult = {
+    created: string[];
+    existing: string[];
+};
+export type ValidationResult = {
+    valid: boolean;
+    errors: string[];
+};
+export type DoctorResult = {
+    ok: boolean;
+    messages: string[];
+};
+export type RecordInput = {
+    type: ArtifactType;
+    title: string;
+    body: string;
+    cwd?: string;
+    date?: Date;
+};
+export type SearchResult = {
+    file: string;
+    line: number;
+    text: string;
+};
+export type ExportResult = {
+    files: string[];
+    markdown: string;
+};
+export declare function isArtifactType(value: string): value is ArtifactType;
+export declare function initRepository(cwd?: string): Promise<InitResult>;
+export declare function validateRepository(cwd?: string): Promise<ValidationResult>;
+export declare function doctorRepository(cwd?: string): Promise<DoctorResult>;
+export declare function recordArtifact(input: RecordInput): Promise<string>;
+export declare function searchMemory(query: string, cwd?: string): Promise<SearchResult[]>;
+export declare function exportMemory(cwd?: string): Promise<ExportResult>;
+//# sourceMappingURL=ithos.d.ts.map

package/dist/ithos.d.ts.map ADDED Viewed

@@ -0,0 +1 @@

+ {"version":3,"file":"ithos.d.ts","sourceRoot":"","sources":["../src/ithos.ts"],"names":[],"mappings":"AAGA,MAAM,MAAM,YAAY,GACpB,cAAc,GACd,WAAW,GACX,SAAS,GACT,UAAU,GACV,MAAM,GACN,SAAS,GACT,UAAU,GACV,aAAa,GACb,UAAU,GACV,UAAU,CAAC;AAEf,MAAM,MAAM,UAAU,GAAG;IACvB,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,QAAQ,EAAE,MAAM,EAAE,CAAC;CACpB,CAAC;AAEF,MAAM,MAAM,gBAAgB,GAAG;IAC7B,KAAK,EAAE,OAAO,CAAC;IACf,MAAM,EAAE,MAAM,EAAE,CAAC;CAClB,CAAC;AAEF,MAAM,MAAM,YAAY,GAAG;IACzB,EAAE,EAAE,OAAO,CAAC;IACZ,QAAQ,EAAE,MAAM,EAAE,CAAC;CACpB,CAAC;AAEF,MAAM,MAAM,WAAW,GAAG;IACxB,IAAI,EAAE,YAAY,CAAC;IACnB,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,MAAM,CAAC;IACb,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,IAAI,CAAC,EAAE,IAAI,CAAC;CACb,CAAC;AAEF,MAAM,MAAM,YAAY,GAAG;IACzB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;CACd,CAAC;AAEF,MAAM,MAAM,YAAY,GAAG;IACzB,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,QAAQ,EAAE,MAAM,CAAC;CAClB,CAAC;AAgCF,wBAAgB,cAAc,CAAC,KAAK,EAAE,MAAM,GAAG,KAAK,IAAI,YAAY,CAEnE;AAED,wBAAsB,cAAc,CAAC,GAAG,SAAgB,GAAG,OAAO,CAAC,UAAU,CAAC,CAoB7E;AAED,wBAAsB,kBAAkB,CACtC,GAAG,SAAgB,GAClB,OAAO,CAAC,gBAAgB,CAAC,CAa3B;AAED,wBAAsB,gBAAgB,CACpC,GAAG,SAAgB,GAClB,OAAO,CAAC,YAAY,CAAC,CAsBvB;AAED,wBAAsB,cAAc,CAAC,KAAK,EAAE,WAAW,GAAG,OAAO,CAAC,MAAM,CAAC,CAiCxE;AAED,wBAAsB,YAAY,CAChC,KAAK,EAAE,MAAM,EACb,GAAG,SAAgB,GAClB,OAAO,CAAC,YAAY,EAAE,CAAC,CA0BzB;AAED,wBAAsB,YAAY,CAAC,GAAG,SAAgB,GAAG,OAAO,CAAC,YAAY,CAAC,CAmB7E"}

package/dist/ithos.js ADDED Viewed

@@ -0,0 +1,278 @@
+import { readdir, readFile, stat, writeFile, mkdir } from "node:fs/promises";
+import path from "node:path";
+const REQUIRED_FILES = [".ithos/README.md", ".ithos/project.md"];
+const ARTIFACT_TYPES = [
+    "architecture",
+    "decisions",
+    "defects",
+    "features",
+    "gaps",
+    "lessons",
+    "patterns",
+    "regressions",
+    "releases",
+    "sessions"
+];
+const DIRECTORY_LAYOUT = [
+    ".ithos",
+    ".ithos/sessions",
+    ".ithos/decisions",
+    ".ithos/architecture",
+    ".ithos/features",
+    ".ithos/patterns",
+    ".ithos/defects",
+    ".ithos/regressions",
+    ".ithos/gaps",
+    ".ithos/lessons",
+    ".ithos/releases",
+    ".ithos/attachments"
+];
+export function isArtifactType(value) {
+    return ARTIFACT_TYPES.includes(value);
+}
+export async function initRepository(cwd = process.cwd()) {
+    const created = [];
+    const existing = [];
+    for (const directory of DIRECTORY_LAYOUT) {
+        const result = await ensureDirectory(path.join(cwd, directory));
+        pushResult(result, directory, created, existing);
+    }
+    const files = new Map([
+        [".ithos/README.md", ithosReadme()],
+        [".ithos/project.md", projectTemplate()]
+    ]);
+    for (const [file, content] of files) {
+        const result = await ensureFile(path.join(cwd, file), content);
+        pushResult(result, file, created, existing);
+    }
+    return { created, existing };
+}
+export async function validateRepository(cwd = process.cwd()) {
+    const errors = [];
+    for (const file of REQUIRED_FILES) {
+        if (!(await exists(path.join(cwd, file)))) {
+            errors.push(`Missing required file: ${file}`);
+        }
+    }
+    return {
+        valid: errors.length === 0,
+        errors
+    };
+}
+export async function doctorRepository(cwd = process.cwd()) {
+    const messages = [];
+    const validation = await validateRepository(cwd);
+    if (validation.valid) {
+        messages.push("Ithos repository structure is valid.");
+    }
+    else {
+        messages.push("Ithos repository structure needs attention.");
+        messages.push(...validation.errors);
+        messages.push("Run `ithos init` to create the required files.");
+    }
+    if (await exists(path.join(cwd, ".git"))) {
+        messages.push("Git repository detected.");
+    }
+    else {
+        messages.push("No .git directory detected. Ithos works best inside Git.");
+    }
+    return {
+        ok: validation.valid,
+        messages
+    };
+}
+export async function recordArtifact(input) {
+    const cwd = input.cwd ?? process.cwd();
+    const now = input.date ?? new Date();
+    const created = formatDate(now);
+    const id = createArtifactId(input.type, input.title, now);
+    const relativeFile = path.join(".ithos", input.type, `${slugify(input.title)}.md`);
+    const absoluteFile = path.join(cwd, relativeFile);
+    await mkdir(path.dirname(absoluteFile), { recursive: true });
+    const markdown = [
+        "---",
+        `id: ${id}`,
+        `type: ${input.type}`,
+        "status: draft",
+        `created: ${created}`,
+        `updated: ${created}`,
+        "tags: []",
+        "---",
+        "",
+        `# ${input.title}`,
+        "",
+        input.body.trim(),
+        ""
+    ].join("\n");
+    await writeFile(absoluteFile, markdown, { flag: "wx" });
+    return relativeFile;
+}
+export async function searchMemory(query, cwd = process.cwd()) {
+    const root = path.join(cwd, ".ithos");
+    if (!(await exists(root))) {
+        return [];
+    }
+    const files = await listMarkdownFiles(root);
+    const normalizedQuery = query.toLowerCase();
+    const results = [];
+    for (const file of files) {
+        const content = await readFile(file, "utf8");
+        const lines = searchableLines(content);
+        lines.forEach((line) => {
+            if (line.text.toLowerCase().includes(normalizedQuery)) {
+                results.push({
+                    file: path.relative(cwd, file),
+                    line: line.number,
+                    text: line.text.trim()
+                });
+            }
+        });
+    }
+    return results;
+}
+export async function exportMemory(cwd = process.cwd()) {
+    const root = path.join(cwd, ".ithos");
+    if (!(await exists(root))) {
+        return { files: [], markdown: "" };
+    }
+    const files = await listMarkdownFiles(root);
+    const sections = [];
+    for (const file of files) {
+        const relativeFile = path.relative(cwd, file);
+        const content = await readFile(file, "utf8");
+        sections.push([`<!-- ${relativeFile} -->`, content.trim(), ""].join("\n"));
+    }
+    return {
+        files: files.map((file) => path.relative(cwd, file)),
+        markdown: sections.join("\n")
+    };
+}
+async function ensureDirectory(directory) {
+    if (await exists(directory)) {
+        return "existing";
+    }
+    await mkdir(directory, { recursive: true });
+    return "created";
+}
+async function ensureFile(file, content) {
+    if (await exists(file)) {
+        return "existing";
+    }
+    await writeFile(file, content, { flag: "wx" });
+    return "created";
+}
+function pushResult(result, file, created, existing) {
+    if (result === "created") {
+        created.push(file);
+    }
+    else {
+        existing.push(file);
+    }
+}
+async function exists(file) {
+    try {
+        await stat(file);
+        return true;
+    }
+    catch (error) {
+        if (isNodeError(error) && error.code === "ENOENT") {
+            return false;
+        }
+        throw error;
+    }
+}
+async function listMarkdownFiles(directory) {
+    const entries = await readdir(directory, { withFileTypes: true });
+    const files = await Promise.all(entries.map(async (entry) => {
+        const absolutePath = path.join(directory, entry.name);
+        if (entry.isDirectory()) {
+            return listMarkdownFiles(absolutePath);
+        }
+        if (entry.isFile() && entry.name.endsWith(".md")) {
+            return [absolutePath];
+        }
+        return [];
+    }));
+    return files.flat().sort();
+}
+function isNodeError(error) {
+    return error instanceof Error && "code" in error;
+}
+function formatDate(date) {
+    const year = date.getFullYear();
+    const month = String(date.getMonth() + 1).padStart(2, "0");
+    const day = String(date.getDate()).padStart(2, "0");
+    return `${year}-${month}-${day}`;
+}
+function createArtifactId(type, title, date) {
+    const prefix = type.slice(0, 3).toUpperCase();
+    const timestamp = [
+        date.getFullYear(),
+        String(date.getMonth() + 1).padStart(2, "0"),
+        String(date.getDate()).padStart(2, "0"),
+        String(date.getHours()).padStart(2, "0"),
+        String(date.getMinutes()).padStart(2, "0"),
+        String(date.getSeconds()).padStart(2, "0")
+    ].join("");
+    return `${prefix}-${timestamp}-${slugify(title)}`;
+}
+function searchableLines(content) {
+    const lines = content.split("\n");
+    if (!content.startsWith("---\n")) {
+        return lines.map((text, index) => ({ number: index + 1, text }));
+    }
+    const end = content.indexOf("\n---\n", 4);
+    if (end === -1) {
+        return lines.map((text, index) => ({ number: index + 1, text }));
+    }
+    const frontmatterLineCount = content
+        .slice(0, end + "\n---\n".length)
+        .split("\n").length;
+    return lines
+        .map((text, index) => ({ number: index + 1, text }))
+        .filter((line) => line.number > frontmatterLineCount);
+}
+function slugify(value) {
+    const slug = value
+        .trim()
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, "-")
+        .replace(/^-+|-+$/g, "");
+    return slug || "untitled";
+}
+function ithosReadme() {
+    return `# Ithos
+This directory preserves the engineering memory for this repository.
+Ithos records why the software changed: decisions, patterns, lessons, defects,
+regressions, gaps, sessions and releases.
+Capture signal, not exhaust. Markdown is the source of truth.
+`;
+}
+function projectTemplate() {
+    return `# Project
+## Summary
+Describe what this project is and why it exists.
+## Goals
+- Preserve engineering memory locally.
+## Technology Stack
+- TypeScript
+## Architecture
+Describe the high-level architecture as it evolves.
+## Conventions
+- Keep markdown human-readable.
+- Prefer concise, factual engineering memory.
+`;
+}

package/dist/ithos.test.d.ts ADDED Viewed

	@@ -0,0 +1,2 @@
1	+ export {};
2	+ //# sourceMappingURL=ithos.test.d.ts.map

package/dist/ithos.test.d.ts.map ADDED Viewed

	@@ -0,0 +1 @@
1	+ {"version":3,"file":"ithos.test.d.ts","sourceRoot":"","sources":["../src/ithos.test.ts"],"names":[],"mappings":""}

package/dist/ithos.test.js ADDED Viewed

@@ -0,0 +1,131 @@
+import { mkdtemp, readFile, rm } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import test from "node:test";
+import assert from "node:assert/strict";
+import { exportMemory, initRepository, recordArtifact, searchMemory, validateRepository } from "./ithos.js";
+test("initRepository creates the required Ithos files", async () => {
+    const cwd = await temporaryDirectory();
+    try {
+        const result = await initRepository(cwd);
+        assert.ok(result.created.includes(".ithos/README.md"));
+        assert.ok(result.created.includes(".ithos/project.md"));
+        const validation = await validateRepository(cwd);
+        assert.equal(validation.valid, true);
+        assert.deepEqual(validation.errors, []);
+    }
+    finally {
+        await removeDirectory(cwd);
+    }
+});
+test("validateRepository reports missing required files", async () => {
+    const cwd = await temporaryDirectory();
+    try {
+        const validation = await validateRepository(cwd);
+        assert.equal(validation.valid, false);
+        assert.deepEqual(validation.errors, [
+            "Missing required file: .ithos/README.md",
+            "Missing required file: .ithos/project.md"
+        ]);
+    }
+    finally {
+        await removeDirectory(cwd);
+    }
+});
+test("recordArtifact creates a markdown artifact without overwriting", async () => {
+    const cwd = await temporaryDirectory();
+    try {
+        await initRepository(cwd);
+        const file = await recordArtifact({
+            cwd,
+            type: "decisions",
+            title: "Use Markdown",
+            body: "Markdown stays readable in Git.",
+            date: new Date("2026-07-02T12:00:00.000Z")
+        });
+        assert.equal(file, ".ithos/decisions/use-markdown.md");
+        const content = await readFile(path.join(cwd, file), "utf8");
+        assert.match(content, /type: decisions/);
+        assert.match(content, /# Use Markdown/);
+        assert.match(content, /Markdown stays readable in Git\./);
+        await assert.rejects(() => recordArtifact({
+            cwd,
+            type: "decisions",
+            title: "Use Markdown",
+            body: "This should not overwrite the original.",
+            date: new Date("2026-07-02T12:01:00.000Z")
+        }), { code: "EEXIST" });
+    }
+    finally {
+        await removeDirectory(cwd);
+    }
+});
+test("recordArtifact uses local dates in frontmatter and ids", async () => {
+    const cwd = await temporaryDirectory();
+    try {
+        await initRepository(cwd);
+        const file = await recordArtifact({
+            cwd,
+            type: "sessions",
+            title: "Local Date",
+            body: "Dates should reflect the local developer calendar.",
+            date: new Date(2026, 6, 3, 0, 5, 0)
+        });
+        const content = await readFile(path.join(cwd, file), "utf8");
+        assert.match(content, /id: SES-20260703000500-local-date/);
+        assert.match(content, /created: 2026-07-03/);
+        assert.match(content, /updated: 2026-07-03/);
+    }
+    finally {
+        await removeDirectory(cwd);
+    }
+});
+test("searchMemory returns matching markdown lines", async () => {
+    const cwd = await temporaryDirectory();
+    try {
+        await initRepository(cwd);
+        await recordArtifact({
+            cwd,
+            type: "lessons",
+            title: "Capture Signal",
+            body: "Capture signal, not exhaust.",
+            date: new Date("2026-07-02T12:00:00.000Z")
+        });
+        const results = await searchMemory("not exhaust", cwd);
+        assert.deepEqual(results, [
+            {
+                file: ".ithos/README.md",
+                line: 8,
+                text: "Capture signal, not exhaust. Markdown is the source of truth."
+            },
+            {
+                file: ".ithos/lessons/capture-signal.md",
+                line: 12,
+                text: "Capture signal, not exhaust."
+            }
+        ]);
+    }
+    finally {
+        await removeDirectory(cwd);
+    }
+});
+test("exportMemory concatenates markdown files", async () => {
+    const cwd = await temporaryDirectory();
+    try {
+        await initRepository(cwd);
+        const result = await exportMemory(cwd);
+        assert.ok(result.files.includes(".ithos/README.md"));
+        assert.ok(result.files.includes(".ithos/project.md"));
+        assert.match(result.markdown, /<!-- \.ithos\/README\.md -->/);
+        assert.match(result.markdown, /<!-- \.ithos\/project\.md -->/);
+    }
+    finally {
+        await removeDirectory(cwd);
+    }
+});
+async function temporaryDirectory() {
+    return mkdtemp(path.join(os.tmpdir(), "ithos-test-"));
+}
+async function removeDirectory(directory) {
+    await rm(directory, { recursive: true, force: true });
+}

package/package.json ADDED Viewed

@@ -0,0 +1,32 @@
+{
+  "name": "ithos",
+  "version": "0.1.0",
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "type": "module",
+  "bin": {
+    "ithos": "./dist/bin/ithos.js"
+  },
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "test": "npm run build && node --test dist/*.test.js",
+    "typecheck": "tsc -p tsconfig.json --noEmit"
+  },
+  "dependencies": {
+    "ithos-core": "*",
+    "commander": "^14.0.0"
+  }
+}