@orqint/cli 0.1.0

package/dist/orqint/types/memory.d.ts

@@ -0,0 +1,49 @@
+/** Canonical Orqint memory (PRD §10 + edge_cases / unknowns / requires_input for CGR-005). */
+export type ProjectMeta = {
+    name: string;
+    type: string;
+    description?: string;
+};
+export type OrqintMemory = {
+    project: ProjectMeta;
+    goals: string[];
+    features: unknown[];
+    pages: unknown[];
+    flows: unknown[];
+    states: unknown[];
+    edge_cases: string[];
+    design_system: Record<string, unknown>;
+    tech_stack: Record<string, unknown>;
+    integrations: unknown[];
+    mcp: unknown[];
+    rules: string[];
+    decisions: unknown[];
+    confidence: number;
+    unknowns: string[];
+    requires_input: boolean;
+    open_questions: string[];
+    validation: Record<string, unknown>;
+    tests: Record<string, unknown>;
+    version: Record<string, unknown>;
+    override: Record<string, boolean | string>;
+};
+export type ThinkApplyPayload = {
+    project?: Partial<ProjectMeta> & {
+        type?: string;
+        name?: string;
+    };
+    project_type?: string;
+    goals?: string[];
+    open_questions?: string[];
+    confidence: number;
+    unknowns?: string[];
+    requires_input?: boolean;
+    tech_stack?: Record<string, unknown>;
+};
+export type PlanApplyPayload = {
+    features?: unknown[];
+    flows?: unknown[];
+    pages?: unknown[];
+    states?: unknown[];
+    edge_cases?: string[];
+};

package/dist/orqint/types/memory.js

@@ -0,0 +1,3 @@
+"use strict";
+/** Canonical Orqint memory (PRD §10 + edge_cases / unknowns / requires_input for CGR-005). */
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/orqint/utils/logger.d.ts

@@ -0,0 +1,2 @@
+export type LogLevel = "debug" | "info" | "warn" | "error";
+export declare function log(level: LogLevel, event: string, data?: Record<string, unknown>): void;

package/dist/orqint/utils/logger.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.log = log;
+function log(level, event, data) {
+    const line = JSON.stringify({
+        ts: new Date().toISOString(),
+        level,
+        event,
+        ...data,
+    });
+    console.error(line);
+}

package/dist/orqint/utils/memory.d.ts

@@ -0,0 +1,8 @@
+import type { OrqintMemory } from "../types/memory";
+export type { OrqintMemory } from "../types/memory";
+export declare const EMPTY_MEMORY: OrqintMemory;
+export declare function ensureDefaults(data: unknown): OrqintMemory;
+export declare function validateFoundation(m: OrqintMemory): void;
+export declare function readMemory(cwd: string): Promise<OrqintMemory>;
+export declare function writeMemory(cwd: string, m: OrqintMemory): Promise<void>;
+export declare function deepMergeTechStack(current: Record<string, unknown>, patch: Record<string, unknown>): Record<string, unknown>;

package/dist/orqint/utils/memory.js

@@ -0,0 +1,157 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EMPTY_MEMORY = void 0;
+exports.ensureDefaults = ensureDefaults;
+exports.validateFoundation = validateFoundation;
+exports.readMemory = readMemory;
+exports.writeMemory = writeMemory;
+exports.deepMergeTechStack = deepMergeTechStack;
+const path = __importStar(require("path"));
+const fs = __importStar(require("fs-extra"));
+const paths_1 = require("../engine/paths");
+const FOUNDATION_KEYS = [
+    "project",
+    "goals",
+    "features",
+    "tech_stack",
+    "rules",
+    "confidence",
+    "open_questions",
+];
+exports.EMPTY_MEMORY = {
+    project: { name: "", type: "" },
+    goals: [],
+    features: [],
+    pages: [],
+    flows: [],
+    states: [],
+    edge_cases: [],
+    design_system: {},
+    tech_stack: {},
+    integrations: [],
+    mcp: [],
+    rules: [],
+    decisions: [],
+    confidence: 0.3,
+    unknowns: [],
+    requires_input: false,
+    open_questions: [],
+    validation: {},
+    tests: {},
+    version: {},
+    override: {},
+};
+function ensureDefaults(data) {
+    const raw = (data ?? {});
+    const projectIn = raw.project;
+    const project = {
+        name: typeof projectIn?.name === "string" ? projectIn.name : "",
+        type: typeof projectIn?.type === "string" ? projectIn.type : "",
+        ...(typeof projectIn?.description === "string"
+            ? { description: projectIn.description }
+            : {}),
+    };
+    const merged = {
+        ...exports.EMPTY_MEMORY,
+        ...raw,
+        project,
+        goals: Array.isArray(raw.goals) ? raw.goals : [],
+        features: Array.isArray(raw.features) ? raw.features : [],
+        pages: Array.isArray(raw.pages) ? raw.pages : [],
+        flows: Array.isArray(raw.flows) ? raw.flows : [],
+        states: Array.isArray(raw.states) ? raw.states : [],
+        edge_cases: Array.isArray(raw.edge_cases)
+            ? raw.edge_cases
+            : [],
+        design_system: isPlainObject(raw.design_system) ? raw.design_system : {},
+        tech_stack: isPlainObject(raw.tech_stack) ? raw.tech_stack : {},
+        integrations: Array.isArray(raw.integrations) ? raw.integrations : [],
+        mcp: Array.isArray(raw.mcp) ? raw.mcp : [],
+        rules: Array.isArray(raw.rules) ? raw.rules : [],
+        decisions: Array.isArray(raw.decisions) ? raw.decisions : [],
+        confidence: typeof raw.confidence === "number" ? raw.confidence : exports.EMPTY_MEMORY.confidence,
+        unknowns: Array.isArray(raw.unknowns) ? raw.unknowns : [],
+        requires_input: typeof raw.requires_input === "boolean"
+            ? raw.requires_input
+            : exports.EMPTY_MEMORY.requires_input,
+        open_questions: Array.isArray(raw.open_questions)
+            ? raw.open_questions
+            : [],
+        validation: isPlainObject(raw.validation) ? raw.validation : {},
+        tests: isPlainObject(raw.tests) ? raw.tests : {},
+        version: isPlainObject(raw.version) ? raw.version : {},
+        override: isPlainObject(raw.override)
+            ? raw.override
+            : {},
+    };
+    return merged;
+}
+function isPlainObject(v) {
+    return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+function validateFoundation(m) {
+    for (const key of FOUNDATION_KEYS) {
+        if (!(key in m) || m[key] === undefined) {
+            throw new Error(`memory.json missing foundation key: ${key}`);
+        }
+    }
+    if (typeof m.confidence !== "number" || Number.isNaN(m.confidence)) {
+        throw new Error("memory.confidence must be a number");
+    }
+    if (!m.project || typeof m.project !== "object") {
+        throw new Error("memory.project must be an object");
+    }
+}
+async function readMemory(cwd) {
+    const p = (0, paths_1.memoryJsonPath)(cwd);
+    const exists = await fs.pathExists(p);
+    if (!exists) {
+        throw new Error(`memory not found at ${p}. Run: orqint init`);
+    }
+    const raw = await fs.readJson(p);
+    const m = ensureDefaults(raw);
+    validateFoundation(m);
+    return m;
+}
+async function writeMemory(cwd, m) {
+    validateFoundation(m);
+    const p = (0, paths_1.memoryJsonPath)(cwd);
+    await fs.ensureDir(path.dirname(p));
+    await fs.writeJson(p, m, { spaces: 2 });
+}
+function deepMergeTechStack(current, patch) {
+    return { ...current, ...patch };
+}

package/dist/orqint/utils/parser.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Extract the first JSON value from raw text (handles ```json fences and prose).
+ */
+export declare function parseJsonFromText(raw: string): unknown;

package/dist/orqint/utils/parser.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseJsonFromText = parseJsonFromText;
+/**
+ * Extract the first JSON value from raw text (handles ```json fences and prose).
+ */
+function parseJsonFromText(raw) {
+    const trimmed = raw.trim();
+    const direct = tryParse(trimmed);
+    if (direct !== undefined) {
+        return direct;
+    }
+    const fence = /```(?:json)?\s*([\s\S]*?)```/i.exec(trimmed);
+    if (fence) {
+        const inner = tryParse(fence[1].trim());
+        if (inner !== undefined) {
+            return inner;
+        }
+    }
+    const firstBrace = trimmed.indexOf("{");
+    const lastBrace = trimmed.lastIndexOf("}");
+    if (firstBrace !== -1 && lastBrace > firstBrace) {
+        const inner = tryParse(trimmed.slice(firstBrace, lastBrace + 1));
+        if (inner !== undefined) {
+            return inner;
+        }
+    }
+    throw new Error("No valid JSON object found in input");
+}
+function tryParse(s) {
+    try {
+        const v = JSON.parse(s);
+        return v;
+    }
+    catch {
+        return undefined;
+    }
+}

package/package.json

@@ -0,0 +1,43 @@
+{
+	"name": "@orqint/cli",
+	"version": "0.1.0",
+	"description": "CLI orchestration for Cursor-native think/plan workflows (Orqint)",
+	"keywords": [
+		"orqint",
+		"cursor",
+		"cli",
+		"orchestration"
+	],
+	"license": "UNLICENSED",
+	"engines": {
+		"node": ">=18"
+	},
+	"bin": {
+		"orqint": "dist/orqint/index.js"
+	},
+	"publishConfig": {
+		"access": "public"
+	},
+	"files": [
+		"dist",
+		"README.md",
+		"AGENTS.md"
+	],
+	"scripts": {
+		"prepublishOnly": "npm run build",
+		"build": "tsc && mkdir -p dist/orqint/prompts && cp packages/cli/prompts/*.txt dist/orqint/prompts/",
+		"orqint": "node dist/orqint/index.js",
+		"cli:install": "bash scripts/setup-cli.sh",
+		"cli:install:pnpm": "pnpm install && pnpm run build && pnpm link --global",
+		"cli:upgrade": "bash scripts/update-cli.sh",
+		"cli:upgrade:pnpm": "pnpm install --no-frozen-lockfile && pnpm run build"
+	},
+	"dependencies": {
+		"fs-extra": "^11.3.4"
+	},
+	"devDependencies": {
+		"@types/fs-extra": "^11.0.4",
+		"@types/node": "^22.15.3",
+		"typescript": "^6.0.2"
+	}
+}